From ed3c44ecbc53a163ac5e40c5789eadd9722009b2 Mon Sep 17 00:00:00 2001 From: Aric Stewart Date: Tue, 4 Jun 2024 07:49:37 -0500 Subject: [PATCH 001/141] steam-helper: Create list of games to ignore selected locale First, and only on this list so far is Guild Wars 2 (1284210) CW-Bug-Id: #23824 --- steam_helper/steam.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/steam_helper/steam.cpp b/steam_helper/steam.cpp index 1eb55b8785..f99596bc5a 100644 --- a/steam_helper/steam.cpp +++ b/steam_helper/steam.cpp @@ -130,6 +130,9 @@ static void setup_steam_registry(void) char buf[256]; HKEY key; LSTATUS status; + const int system_locale_appids[] = { + 1284210 /* Guild Wars 2 */ + }; ui_lang = SteamUtils()->GetSteamUILanguage(); WINE_TRACE("UI language: %s\n", wine_dbgstr_a(ui_lang)); @@ -156,6 +159,18 @@ static void setup_steam_registry(void) languages = SteamApps()->GetAvailableGameLanguages(); WINE_TRACE( "Game language %s, available %s\n", wine_dbgstr_a(language), wine_dbgstr_a(languages) ); + if (strchr(languages, ',') == NULL) /* If there is a list of languages then respect that */ + { + for (int i = 0; i < (sizeof(system_locale_appids) / sizeof(*system_locale_appids)); i++) + { + if (system_locale_appids[i] == appid) + { + WINE_TRACE("Not changing system locale for application %i\n",appid); + language = NULL; + } + } + } + if (!language) locale = NULL; else if (!strcmp( language, "arabic" )) locale = "ar_001.UTF-8"; else if (!strcmp( language, "bulgarian" )) locale = "bg_BG.UTF-8"; From 95ff2846f2eb143f43a842bad3ca9b43f46bf2ad Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Fri, 24 May 2024 20:00:07 +0000 Subject: [PATCH 002/141] proton: Use STEAM_COMPAT_APP_ID to decide when to run xalia. CW-Bug-Id: #23808 SteamAppId isn't set for InstallScripts, but this variable is. --- proton | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proton b/proton index 0c8e1ca34b..929def2e39 100755 --- a/proton +++ b/proton @@ -1150,6 +1150,8 @@ def default_compat_config(): ]: ret.add("hideapu") + if "STEAM_COMPAT_APP_ID" in os.environ: + appid = os.environ["STEAM_COMPAT_APP_ID"] if appid in [ "7000", # Tomb Raider: Legend "8000", # Tomb Raider: Anniversary From 6c84bc49dd3e0de719a27b4505578f3b5c0577e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bernhard=20K=C3=B6lbl?= Date: Wed, 28 Jun 2023 11:56:37 +0200 Subject: [PATCH 003/141] build: Add and build OpenFST submodule. --- .gitmodules | 3 +++ Makefile.in | 40 ++++++++++++++++++++++++++++++++++++++++ openfst | 1 + 3 files changed, 44 insertions(+) create mode 160000 openfst diff --git a/.gitmodules b/.gitmodules index 7d00a6d4c7..09157900d1 100644 --- a/.gitmodules +++ b/.gitmodules @@ -55,3 +55,6 @@ [submodule "glslang"] path = glslang url = https://github.com/KhronosGroup/glslang +[submodule "openfst"] + path = openfst + url = https://github.com/alphacep/openfst diff --git a/Makefile.in b/Makefile.in index 44d0447e28..dd618402be 100644 --- a/Makefile.in +++ b/Makefile.in @@ -381,6 +381,46 @@ $(OBJ)/.steamexe-post-build64: cp $(SRC)/steam_helper/64/libsteam_api.so $(DST_LIBDIR64)/ touch $@ +## +## openfst +## + +OPENFST_SOURCE_ARGS = \ + --include src/include/fst/config.h.in \ + --exclude aclocal.m4 \ + --exclude ar-lib \ + --exclude autom4te.cache \ + --exclude compile \ + --exclude config.guess \ + --exclude config.h.in \ + --exclude config.sub \ + --exclude configure \ + --exclude depcomp \ + --exclude install-sh \ + --exclude ltmain.sh \ + --exclude m4/libtool.m4 \ + --exclude m4/ltoptions.m4 \ + --exclude m4/ltsugar.m4 \ + --exclude m4/ltversion.m4 \ + --exclude m4/lt~obsolete.m4 \ + --exclude Makefile.in \ + --exclude missing \ + --exclude test-driver \ + +OPENFST_CONFIGURE_ARGS = \ + --enable-silent-rules \ + --enable-static \ + --disable-shared \ + --enable-far \ + --enable-ngram-fsts \ + --enable-lookahead-fsts \ + --with-pic \ + --disable-bin \ + +$(eval $(call rules-source,openfst,$(SRCDIR)/openfst)) +$(eval $(call rules-autoconf,openfst,32)) +$(eval $(call rules-autoconf,openfst,64)) + ## ## wine diff --git a/openfst b/openfst new file mode 160000 index 0000000000..7dfd808194 --- /dev/null +++ b/openfst @@ -0,0 +1 @@ +Subproject commit 7dfd808194105162f20084bb4d8e4ee4b65266d5 From 265c5cf4dc3d496e8a1d98712342dbcf2658b5c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bernhard=20K=C3=B6lbl?= Date: Wed, 28 Jun 2023 12:02:05 +0200 Subject: [PATCH 004/141] build: Add and build Kaldi submodule. --- .gitmodules | 4 ++++ Makefile.in | 23 +++++++++++++++++++++++ kaldi | 1 + 3 files changed, 28 insertions(+) create mode 160000 kaldi diff --git a/.gitmodules b/.gitmodules index 09157900d1..0089ed4ce2 100644 --- a/.gitmodules +++ b/.gitmodules @@ -58,3 +58,7 @@ [submodule "openfst"] path = openfst url = https://github.com/alphacep/openfst +[submodule "kaldi"] + path = kaldi + url = https://github.com/alphacep/kaldi + branch = vosk diff --git a/Makefile.in b/Makefile.in index dd618402be..133ff99c5c 100644 --- a/Makefile.in +++ b/Makefile.in @@ -422,6 +422,29 @@ $(eval $(call rules-autoconf,openfst,32)) $(eval $(call rules-autoconf,openfst,64)) +## +## kaldi +## + +KALDI_SOURCE_ARGS = \ + --exclude src/**/CMakeLists.txt \ + +KALDI_CMAKE_ARGS = \ + -DKALDI_VERSION=5.5-proton \ + -DBLAS_LIBRARIES=-lblas \ + -DLAPACK_LIBRARIES=-llapack \ + -DCMAKE_POSITION_INDEPENDENT_CODE=ON \ + -DBUILD_SHARED_LIBS=OFF \ + -DKALDI_BUILD_TEST=OFF \ + -DKALDI_BUILD_EXE=OFF \ + +KALDI_DEPENDS = openfst + +$(eval $(call rules-source,kaldi,$(SRCDIR)/kaldi)) +$(eval $(call rules-cmake,kaldi,32)) +$(eval $(call rules-cmake,kaldi,64)) + + ## ## wine ## diff --git a/kaldi b/kaldi new file mode 160000 index 0000000000..a25f216f5c --- /dev/null +++ b/kaldi @@ -0,0 +1 @@ +Subproject commit a25f216f5ce4eec5e45a6ab7651e20c9840a05cd From 12e3262ec7c0c6d352a393b5e7bfedd1f4d8af77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bernhard=20K=C3=B6lbl?= Date: Wed, 28 Jun 2023 12:04:05 +0200 Subject: [PATCH 005/141] build: Add and build Vosk submodule. --- .gitmodules | 3 +++ Makefile.in | 16 +++++++++++++++- vosk-api | 1 + 3 files changed, 19 insertions(+), 1 deletion(-) create mode 160000 vosk-api diff --git a/.gitmodules b/.gitmodules index 0089ed4ce2..97c65c800e 100644 --- a/.gitmodules +++ b/.gitmodules @@ -62,3 +62,6 @@ path = kaldi url = https://github.com/alphacep/kaldi branch = vosk +[submodule "vosk-api"] + path = vosk-api + url = https://github.com/alphacep/vosk-api diff --git a/Makefile.in b/Makefile.in index 133ff99c5c..25f4c89133 100644 --- a/Makefile.in +++ b/Makefile.in @@ -445,6 +445,20 @@ $(eval $(call rules-cmake,kaldi,32)) $(eval $(call rules-cmake,kaldi,64)) +## +## vosk +## + +VOSK_CMAKE_ARGS = \ + -DBUILD_SHARED_LIBS=ON \ + +VOSK_DEPENDS = openfst kaldi + +$(eval $(call rules-source,vosk,$(SRCDIR)/vosk-api)) +$(eval $(call rules-cmake,vosk,32)) +$(eval $(call rules-cmake,vosk,64)) + + ## ## wine ## @@ -477,7 +491,7 @@ WINE_CONFIGURE_ARGS64 = --enable-win64 \ VKD3D_PE_CFLAGS="-I$(VULKAN_HEADERS_DST64)/include -I$(VKD3D_DST64)/include/vkd3d" \ VKD3D_PE_LIBS="-L$(VKD3D_DST64)/bin -l:libvkd3d-1.dll -l:libvkd3d-shader-1.dll" -WINE_DEPENDS = gst_orc gstreamer gst_base vkd3d +WINE_DEPENDS = gst_orc gstreamer gst_base vkd3d openfst kaldi vosk $(eval $(call rules-source,wine,$(SRCDIR)/wine)) $(eval $(call rules-autoconf,wine,32)) diff --git a/vosk-api b/vosk-api new file mode 160000 index 0000000000..12f29a3415 --- /dev/null +++ b/vosk-api @@ -0,0 +1 @@ +Subproject commit 12f29a3415e4967e088ed09202bfb0007e5a1787 From 16922663004e97af9d9c422a79a57ff6e8477176 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Tue, 21 Mar 2023 14:46:02 +0200 Subject: [PATCH 006/141] proton: Make copying d3d12core for vkd3d-proton mandatory. --- proton | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/proton b/proton index 929def2e39..26b6815a1b 100755 --- a/proton +++ b/proton @@ -953,13 +953,10 @@ class CompatData: g_session.dlloverrides[f] = "n" for f in vkd3d_protonfiles: - optional = False - if f == "d3d12core": - optional = True try_copy(g_proton.lib64_dir + "wine/vkd3d-proton/" + f + ".dll", "drive_c/windows/system32", - prefix=self.prefix_dir, track_file=tracked_files, link_debug=True, optional=optional) + prefix=self.prefix_dir, track_file=tracked_files, link_debug=True) try_copy(g_proton.lib_dir + "wine/vkd3d-proton/" + f + ".dll", "drive_c/windows/syswow64", - prefix=self.prefix_dir, track_file=tracked_files, link_debug=True, optional=optional) + prefix=self.prefix_dir, track_file=tracked_files, link_debug=True) g_session.dlloverrides[f] = "n" # If the user requested the NVAPI be available, copy it into place. From 5c849362419350a28611c531ba8c41ad9f1e85a1 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 5 May 2023 16:26:03 +0300 Subject: [PATCH 007/141] Bump prefix version to one higher than Proton Stable. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 26b6815a1b..9a508ae7f4 100755 --- a/proton +++ b/proton @@ -40,7 +40,7 @@ from random import randrange #To enable debug logging, copy "user_settings.sample.py" to "user_settings.py" #and edit it if needed. -CURRENT_PREFIX_VERSION="9.0-200" +CURRENT_PREFIX_VERSION="9.0-201" PFX="Proton: " ld_path_var = "LD_LIBRARY_PATH" From 9c844ee7eca3115538916e03b25d44d125a5c0dd Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Mon, 11 Dec 2023 13:54:13 -0600 Subject: [PATCH 008/141] Revert "proton: Disable forced LAA for Final Fantsy X/X-2." This reverts commit a090d16b3fa6bcc4941da8bd0b145ff32cef6836. --- proton | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/proton b/proton index 9a508ae7f4..30af9be197 100755 --- a/proton +++ b/proton @@ -1072,10 +1072,7 @@ def default_compat_config(): ]: ret.add("noopwr") - if appid in [ - "1621680", - "359870", - ]: + if appid == "1621680": ret.add("noforcelgadd") if appid in [ From d7ab7f91997517191ecaeef5e7f3eab8072a970d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Tue, 9 Jan 2024 18:33:53 +0100 Subject: [PATCH 009/141] lsteamclient: Execute any pending callback before ReleaseRequest. CW-Bug-Id: #22729 --- lsteamclient/steamclient_private.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lsteamclient/steamclient_private.h b/lsteamclient/steamclient_private.h index dc754c7089..fb1e912ed5 100644 --- a/lsteamclient/steamclient_private.h +++ b/lsteamclient/steamclient_private.h @@ -42,6 +42,8 @@ extern struct w_steam_iface *create_winISteamNetworkingFakeUDPPort_SteamNetworki extern void execute_pending_callbacks(void); +extern void execute_pending_callbacks(void); + struct w_steam_iface *create_win_interface(const char *name, void *linux_side); void *alloc_mem_for_iface(size_t size, const char *iface_version); void *alloc_vtable(void *vtable, unsigned int method_count, const char *iface_version); From 40aff8b01172071a006ecbba94682da920708a6d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 11 Jan 2024 20:55:07 +0100 Subject: [PATCH 010/141] proton: Reset the SteamVirtualGamepadInfo environment variable. To keep SDL 2.30 old behavior until we start supporting it. CW-Bug-Id: #23185 --- proton | 3 +++ 1 file changed, 3 insertions(+) diff --git a/proton b/proton index 30af9be197..baf0720d03 100755 --- a/proton +++ b/proton @@ -1546,6 +1546,9 @@ if __name__ == "__main__": log("No compat data path?") sys.exit(1) + # CW-Bug-Id: #23185 Avoid triggering new SDL 2.30 behavior. + os.environ.pop('SteamVirtualGamepadInfo', None) + g_proton = Proton(os.path.dirname(sys.argv[0])) g_proton.cleanup_legacy_dist() From 9de270edb5a4419705f1e4aa816e3cf4c490e4ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Tue, 23 Jan 2024 09:43:02 +0100 Subject: [PATCH 011/141] proton: Enable the new SDL 2.30 Steam Input integration. CW-Bug-Id: #23185 --- proton | 3 --- 1 file changed, 3 deletions(-) diff --git a/proton b/proton index baf0720d03..30af9be197 100755 --- a/proton +++ b/proton @@ -1546,9 +1546,6 @@ if __name__ == "__main__": log("No compat data path?") sys.exit(1) - # CW-Bug-Id: #23185 Avoid triggering new SDL 2.30 behavior. - os.environ.pop('SteamVirtualGamepadInfo', None) - g_proton = Proton(os.path.dirname(sys.argv[0])) g_proton.cleanup_legacy_dist() From a0d4389aa34277fbac6fe6adf9bba5aa2aa69bf3 Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Fri, 24 Feb 2023 15:06:10 -0600 Subject: [PATCH 012/141] Remove files that failed to download. In some cases, wget -O will create the file even when the download fails. This is not removed by make and will make subsequent failures more confusing, as well as failing to recover if the cause was an intermittent network failure. --- Makefile.in | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Makefile.in b/Makefile.in index 25f4c89133..0d08933c23 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1001,11 +1001,11 @@ DIST_GECKO64 := $(OBJ)/.gecko-dist64 $(SRC)/contrib/$(GECKO64_TARBALL): mkdir -p $(dir $@) - wget --no-use-server-timestamps -O $@ $(GECKO64_TARBALL_URL) + wget --no-use-server-timestamps -O $@ $(GECKO64_TARBALL_URL) || (rm $@; false) $(SRC)/contrib/$(GECKO32_TARBALL): mkdir -p $(dir $@) - wget --no-use-server-timestamps -O $@ $(GECKO32_TARBALL_URL) + wget --no-use-server-timestamps -O $@ $(GECKO32_TARBALL_URL) || (rm $@; false) $(DIST_GECKO32): $(SRC)/contrib/$(GECKO32_TARBALL) mkdir -p $(DIST_GECKO_DIR) @@ -1034,7 +1034,7 @@ MONO_TARBALL_URL := https://github.com/madewokherd/wine-mono/releases/download/w $(SRC)/contrib/$(WINEMONO_TARBALL): mkdir -p $(dir $@) - wget --no-use-server-timestamps -O $@ $(MONO_TARBALL_URL) + wget --no-use-server-timestamps -O $@ $(MONO_TARBALL_URL) || (rm $@; false) $(DIST_WINEMONO): $(SRC)/contrib/$(WINEMONO_TARBALL) mkdir -p $(DIST_WINEMONO_DIR) From 7b9e20d1b5edf78ef9d50981a4aaf8fa08c34daa Mon Sep 17 00:00:00 2001 From: Eric Pouech Date: Tue, 2 Apr 2024 10:34:53 +0200 Subject: [PATCH 013/141] Makefile.in: Don't fail when updating openvr_api_dxvk.dll. These files are copied into lib(64)/wine/dxvk with user-write permission, which is later removed by default_pfx: rule. Hence failing to 'cp' upon update. --- Makefile.in | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile.in b/Makefile.in index 0d08933c23..bbbef5eee4 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1075,12 +1075,12 @@ all-dist: $(DIST_XALIA) DIST_OVR32 := $(DST_LIBDIR32)/wine/dxvk/openvr_api_dxvk.dll $(DIST_OVR32): $(SRCDIR)/openvr/bin/win32/openvr_api.dll | $(DST_DIR) mkdir -p $(DST_LIBDIR32)/wine/dxvk - cp -a $< $@ + cp -af $< $@ DIST_OVR64 := $(DST_LIBDIR64)/wine/dxvk/openvr_api_dxvk.dll $(DIST_OVR64): $(SRCDIR)/openvr/bin/win64/openvr_api.dll | $(DST_DIR) mkdir -p $(DST_LIBDIR64)/wine/dxvk - cp -a $< $@ + cp -af $< $@ all-dist: $(DIST_OVR32) $(DIST_OVR64) From 6b8b996001cc0c657bf1431cd608ef2c9b1c5d54 Mon Sep 17 00:00:00 2001 From: Yuxuan Shui Date: Wed, 8 May 2024 14:58:03 +0100 Subject: [PATCH 014/141] wineopenxr: Print warnings if the application is giving us funny swapchain formats. --- wineopenxr/openxr.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/wineopenxr/openxr.c b/wineopenxr/openxr.c index 9a3e7a4172..7414483049 100644 --- a/wineopenxr/openxr.c +++ b/wineopenxr/openxr.c @@ -1455,6 +1455,29 @@ XrResult WINAPI wine_xrGetSystem(XrInstance instance, const XrSystemGetInfo *get return res; } +static BOOL is_vulkan_format_depth(VkFormat format) +{ + switch(format){ + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + return FALSE; + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + return TRUE; + + default: + WINE_WARN("Unknown vulkan format %#x", format); + return FALSE; + } +} + int64_t map_format_dxgi_to_vulkan(int64_t format) { switch(format){ @@ -1598,6 +1621,7 @@ XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreat wine_swapchain->create_info = *createInfo; if(wine_session->session_type == SESSION_TYPE_D3D11){ + BOOL format_is_depth; our_createInfo = *createInfo; our_createInfo.format = map_format_dxgi_to_vulkan(createInfo->format); if(our_createInfo.format == VK_FORMAT_UNDEFINED){ @@ -1606,6 +1630,14 @@ XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreat return XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED; } createInfo = &our_createInfo; + + format_is_depth = is_vulkan_format_depth(our_createInfo.format); + if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT) && format_is_depth){ + WINE_WARN("Swapchain has a color attachment usage, but it's format is for depth\n"); + } + if ((createInfo->usageFlags & XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !format_is_depth){ + WINE_WARN("Swapchain has a depth/stencil usage, but it's format is for color\n"); + } } res = xrCreateSwapchain(((wine_XrSession *)session)->session, createInfo, &wine_swapchain->swapchain); From d18ff80721f736cf9d8255c42f620f2e2adfbfa9 Mon Sep 17 00:00:00 2001 From: Yuxuan Shui Date: Wed, 8 May 2024 15:11:24 +0100 Subject: [PATCH 015/141] wineopenxr: Don't recreate swapchain images for subsequent calls to EnumerateSwapchainImages. --- wineopenxr/openxr.c | 76 ++++++++++++++++++++++++++----------- wineopenxr/openxr_private.h | 2 + 2 files changed, 55 insertions(+), 23 deletions(-) diff --git a/wineopenxr/openxr.c b/wineopenxr/openxr.c index 7414483049..df68637513 100644 --- a/wineopenxr/openxr.c +++ b/wineopenxr/openxr.c @@ -1663,12 +1663,22 @@ XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain) WINE_TRACE("%p\n", swapchain); + if (wine_swapchain->image_count){ + UINT i; + if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ + XrSwapchainImageD3D11KHR *d3d11_images = (XrSwapchainImageD3D11KHR *)wine_swapchain->images; + for (i = 0; i < wine_swapchain->image_count; i++) + d3d11_images[i].texture->lpVtbl->Release(d3d11_images[i].texture); + } + heap_free(wine_swapchain->images); + wine_swapchain->image_count = 0; + } + res = xrDestroySwapchain(wine_swapchain->swapchain); if(res != XR_SUCCESS){ WINE_WARN("xrDestroySwapchain failed: %d\n", res); return res; } - heap_free(wine_swapchain); return XR_SUCCESS; @@ -1700,28 +1710,34 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; wine_XrInstance *wine_instance = wine_swapchain->wine_session->wine_instance; XrResult res; - XrSwapchainImageVulkanKHR *our_images = NULL; - XrSwapchainImageBaseHeader *their_images = images; + XrSwapchainImageVulkanKHR *our_vk = NULL; HRESULT hr; - uint32_t i; + size_t image_size = 0; + uint32_t i, to_copy; WINE_TRACE("%p, %u, %p, %p\n", swapchain, imageCapacityInput, imageCountOutput, images); - - if(images){ - if(wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ - our_images = heap_alloc(sizeof(*our_images) * imageCapacityInput); - for(i = 0; i < imageCapacityInput; ++i){ - our_images[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR; - } - images = (XrSwapchainImageBaseHeader *)our_images; + if (wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D11) + return xrEnumerateSwapchainImages(wine_swapchain->swapchain, imageCapacityInput, imageCountOutput, images); + + if (!wine_swapchain->image_count) { + uint32_t image_count; + res = xrEnumerateSwapchainImages(wine_swapchain->swapchain, 0, &image_count, NULL); + if (res != XR_SUCCESS) + return res; + + our_vk = heap_alloc(sizeof(*our_vk) * image_count); + for(i = 0; i < image_count; ++i){ + our_vk[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR; } - } - res = xrEnumerateSwapchainImages(wine_swapchain->swapchain, imageCapacityInput, imageCountOutput, images); + res = xrEnumerateSwapchainImages(wine_swapchain->swapchain, image_count, &image_count, (XrSwapchainImageBaseHeader *)our_vk); + if (res != XR_SUCCESS){ + heap_free(our_vk); + return res; + } - if(images && res == XR_SUCCESS){ if(wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ - XrSwapchainImageD3D11KHR *their_d3d11; + XrSwapchainImageD3D11KHR *our_d3d11; D3D11_TEXTURE2D_DESC1 desc; desc.Width = wine_swapchain->create_info.width; @@ -1739,21 +1755,35 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t desc.MiscFlags = 0; desc.TextureLayout = D3D11_TEXTURE_LAYOUT_UNDEFINED; - their_d3d11 = (XrSwapchainImageD3D11KHR *)their_images; - for(i = 0; i < *imageCountOutput; ++i){ + our_d3d11 = heap_alloc(sizeof(XrSwapchainImageD3D11KHR) * image_count); + for(i = 0; i < image_count; ++i){ hr = wine_instance->dxvk_device->lpVtbl->CreateTexture2DFromVkImage(wine_instance->dxvk_device, - &desc, our_images[i].image, &their_d3d11[i].texture); + &desc, our_vk[i].image, &our_d3d11[i].texture); if(FAILED(hr)){ + UINT j; + for (j = 0; j < i; ++j){ + our_d3d11[i].texture->lpVtbl->Release(our_d3d11[i].texture); + } + heap_free(our_d3d11); + heap_free(our_vk); WINE_WARN("Failed to create DXVK texture from VkImage: %08x\n", hr); - return XR_ERROR_INSTANCE_LOST; + return XR_ERROR_RUNTIME_FAILURE; } - WINE_TRACE("Successfully allocated texture %p\n", their_d3d11[i].texture); + WINE_TRACE("Successfully allocated texture %p\n", our_d3d11[i].texture); } + wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d11; } + heap_free(our_vk); + wine_swapchain->image_count = image_count; } - heap_free(our_images); - return res; + to_copy = min(wine_swapchain->image_count, imageCapacityInput); + *imageCountOutput = wine_swapchain->image_count; + if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ + image_size = sizeof(XrSwapchainImageD3D11KHR); + } + memcpy(images, wine_swapchain->images, image_size * to_copy); + return XR_SUCCESS; } static XrCompositionLayerBaseHeader *convert_XrCompositionLayer(wine_XrSession *wine_session, diff --git a/wineopenxr/openxr_private.h b/wineopenxr/openxr_private.h index 7f1b7411c9..e110291d57 100644 --- a/wineopenxr/openxr_private.h +++ b/wineopenxr/openxr_private.h @@ -49,6 +49,8 @@ typedef struct wine_XrSession { typedef struct wine_XrSwapchain{ XrSwapchain swapchain; + XrSwapchainImageBaseHeader *images; + uint32_t image_count; struct wine_XrSession *wine_session; XrSwapchainCreateInfo create_info; From 7b3d5f33baf24463e070150f836df0cc2bfdafe7 Mon Sep 17 00:00:00 2001 From: Yuxuan Shui Date: Thu, 9 May 2024 22:29:00 +0100 Subject: [PATCH 016/141] wineopenxr: Support creating a D3D12 XR instance. --- wineopenxr/openxr.c | 179 ++++++++++++++++++++++++++-- wineopenxr/openxr_private.h | 5 + wineopenxr/vkd3d-proton-interop.h | 186 ++++++++++++++++++++++++++++++ 3 files changed, 359 insertions(+), 11 deletions(-) create mode 100644 wineopenxr/vkd3d-proton-interop.h diff --git a/wineopenxr/openxr.c b/wineopenxr/openxr.c index df68637513..cbc1bd949e 100644 --- a/wineopenxr/openxr.c +++ b/wineopenxr/openxr.c @@ -28,6 +28,7 @@ #include "wine/vulkan.h" #define VULKAN_H_ 1// tell dxvk-interop not to include vulkan.h #include "dxvk-interop.h" +#include "vkd3d-proton-interop.h" #undef WINE_VK_HOST #define XR_USE_GRAPHICS_API_D3D11 1 #define XR_USE_GRAPHICS_API_D3D12 1 @@ -79,6 +80,7 @@ static struct substitute_extensions[] = { {"XR_KHR_D3D11_enable", "XR_KHR_vulkan_enable"}, + {"XR_KHR_D3D12_enable", "XR_KHR_vulkan_enable"}, {"XR_KHR_win32_convert_performance_counter_time", "XR_KHR_convert_timespec_time", TRUE, TRUE}, }; @@ -682,7 +684,6 @@ XrResult WINAPI wine_xrEnumerateInstanceExtensionProperties(const char *layerNam else dst = (*propertyCountOutput)++; strcpy(properties[dst].extensionName, substitute_extensions[j].win32_ext); - break; } } } @@ -790,9 +791,13 @@ XrResult WINAPI wine_xrGetD3D11GraphicsRequirementsKHR(XrInstance instance, XrResult WINAPI wine_xrGetD3D12GraphicsRequirementsKHR(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR *graphicsRequirements) { - WINE_FIXME("unimplemented\n"); - /* FIXME */ - return XR_ERROR_INITIALIZATION_FAILED; + XrGraphicsRequirementsD3D11KHR requirements; + XrResult result = wine_xrGetD3D11GraphicsRequirementsKHR(instance, systemId, &requirements); + if (result != XR_SUCCESS) + return result; + graphicsRequirements->adapterLuid = requirements.adapterLuid; + graphicsRequirements->minFeatureLevel = D3D_FEATURE_LEVEL_11_0; + return XR_SUCCESS; } XrResult WINAPI wine_xrGetInstanceProcAddr(XrInstance instance, const char *fn_name, PFN_xrVoidFunction *out_fn) @@ -907,6 +912,12 @@ XrResult WINAPI wine_xrDestroyInstance(XrInstance instance) if(wine_instance->dxvk_device) wine_instance->dxvk_device->lpVtbl->Release(wine_instance->dxvk_device); + if (wine_instance->d3d12_device) + { + wine_instance->d3d12_device->lpVtbl->Release(wine_instance->d3d12_device); + wine_instance->d3d12_queue->lpVtbl->Release(wine_instance->d3d12_queue); + } + heap_free(wine_instance); return XR_SUCCESS; @@ -1041,6 +1052,60 @@ XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateI break; } + case XR_TYPE_GRAPHICS_BINDING_D3D12_KHR: + { + const XrGraphicsBindingD3D12KHR *their_d3d12_binding = createInfo->next; + HRESULT hr; + UINT32 queue_index; + VkQueueFlags queue_flags; + ID3D12DeviceExt1 *device_ext; + hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DXVKInteropDevice, (void**)&wine_instance->d3d12_device); + if (FAILED(hr)) + { + WINE_WARN("Given ID3D12Device doesn't support ID3D12DXVKInteropDevice. Only vkd3d-proton is supported.\n"); + return XR_ERROR_VALIDATION_FAILURE; + } + hr = ID3D12Device_QueryInterface(their_d3d12_binding->device, &IID_ID3D12DeviceExt1, (void **)&device_ext); + if (FAILED(hr)) + { + WINE_WARN("Given ID3D12Device doesn't support ID3D12DeviceExt1. Only vkd3d-proton is supported.\n"); + return XR_ERROR_VALIDATION_FAILURE; + } + + our_vk_binding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; + our_vk_binding.next = NULL; + + wine_instance->d3d12_queue = their_d3d12_binding->queue; + their_d3d12_binding->queue->lpVtbl->AddRef(their_d3d12_binding->queue); + + wine_instance->d3d12_device->lpVtbl->GetVulkanHandles(wine_instance->d3d12_device, + &our_vk_binding.instance, &our_vk_binding.physicalDevice, &our_vk_binding.device); + device_ext->lpVtbl->GetVulkanQueueInfoEx(device_ext, their_d3d12_binding->queue, + &wine_instance->vk_queue, &queue_index, &queue_flags, &our_vk_binding.queueFamilyIndex); + device_ext->lpVtbl->Release(device_ext); + + wine_instance->vk_device = our_vk_binding.device = get_native_VkDevice(our_vk_binding.device); + wine_instance->vk_queue = get_native_VkQueue(wine_instance->vk_queue); + our_vk_binding.queueIndex = queue_index; + + our_vk_binding.instance = get_native_VkInstance(our_vk_binding.instance); + + if ((res = do_vulkan_init(wine_instance, our_vk_binding.instance)) != XR_SUCCESS) + return res; + + if (wine_instance->vk_phys_dev != get_native_VkPhysicalDevice(our_vk_binding.physicalDevice)) + WINE_WARN("VK physical device does not match that from xrGetVulkanGraphicsDeviceKHR.\n"); + + our_vk_binding.physicalDevice = wine_instance->vk_phys_dev; + + our_create_info = *createInfo; + our_create_info.next = &our_vk_binding; + createInfo = &our_create_info; + + session_type = SESSION_TYPE_D3D12; + + break; + } default: WINE_WARN("Unhandled graphics binding type: %d\n", ((XrBaseInStructure *)createInfo->next)->type); break; @@ -1572,7 +1637,7 @@ XrResult WINAPI wine_xrEnumerateSwapchainFormats(XrSession session, uint32_t for WINE_TRACE("%p, %u, %p, %p\n", session, formatCapacityInput, formatCountOutput, formats); - if (wine_session->session_type != SESSION_TYPE_D3D11) + if (wine_session->session_type != SESSION_TYPE_D3D11 && wine_session->session_type != SESSION_TYPE_D3D12) return xrEnumerateSwapchainFormats(wine_session->session, formatCapacityInput, formatCountOutput, formats); res = xrEnumerateSwapchainFormats(wine_session->session, 0, &real_format_count, NULL); @@ -1620,7 +1685,7 @@ XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreat wine_swapchain = heap_alloc_zero(sizeof(*wine_swapchain)); wine_swapchain->create_info = *createInfo; - if(wine_session->session_type == SESSION_TYPE_D3D11){ + if(wine_session->session_type == SESSION_TYPE_D3D11 || wine_session->session_type == SESSION_TYPE_D3D12){ BOOL format_is_depth; our_createInfo = *createInfo; our_createInfo.format = map_format_dxgi_to_vulkan(createInfo->format); @@ -1656,6 +1721,18 @@ XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreat return XR_SUCCESS; } +static void release_d3d12_resources(wine_XrSwapchain *wine_swapchain, uint32_t image_count) +{ + XrSwapchainImageD3D12KHR *d3d12_images = (XrSwapchainImageD3D12KHR *)wine_swapchain->images; + UINT i; + if (!image_count) + return; + + for (i = 0; i < image_count; i++) + if (d3d12_images[i].texture) + d3d12_images[i].texture->lpVtbl->Release(d3d12_images[i].texture); +} + XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain) { wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; @@ -1669,7 +1746,8 @@ XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain) XrSwapchainImageD3D11KHR *d3d11_images = (XrSwapchainImageD3D11KHR *)wine_swapchain->images; for (i = 0; i < wine_swapchain->image_count; i++) d3d11_images[i].texture->lpVtbl->Release(d3d11_images[i].texture); - } + } else if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12) + release_d3d12_resources(wine_swapchain, wine_swapchain->image_count); heap_free(wine_swapchain->images); wine_swapchain->image_count = 0; } @@ -1713,10 +1791,10 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t XrSwapchainImageVulkanKHR *our_vk = NULL; HRESULT hr; size_t image_size = 0; - uint32_t i, to_copy; + uint32_t i; WINE_TRACE("%p, %u, %p, %p\n", swapchain, imageCapacityInput, imageCountOutput, images); - if (wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D11) + if (wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D11 && wine_swapchain->wine_session->session_type != SESSION_TYPE_D3D12) return xrEnumerateSwapchainImages(wine_swapchain->swapchain, imageCapacityInput, imageCountOutput, images); if (!wine_swapchain->image_count) { @@ -1772,17 +1850,80 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t WINE_TRACE("Successfully allocated texture %p\n", our_d3d11[i].texture); } wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d11; + } else if(wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12){ + XrSwapchainImageD3D12KHR *our_d3d12; + D3D12_RESOURCE_DESC1 desc; + ID3D12DeviceExt1 *device_ext; + HRESULT hr = wine_instance->d3d12_device->lpVtbl->QueryInterface(wine_instance->d3d12_device, &IID_ID3D12DeviceExt1, (void **)&device_ext); + BOOL format_is_depth = is_vulkan_format_depth(map_format_dxgi_to_vulkan(wine_swapchain->create_info.format)); + BOOL succeeded = TRUE; + if (FAILED(hr)) + { + WINE_ERR("Cannot get vkd3d-proton interface: %08x\n", hr); + return XR_ERROR_VALIDATION_FAILURE; + } + + desc.Alignment = 0; + desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + desc.Width = wine_swapchain->create_info.width; + desc.Height = wine_swapchain->create_info.height; + desc.MipLevels = wine_swapchain->create_info.mipCount; + desc.DepthOrArraySize = wine_swapchain->create_info.arraySize; + desc.Format = wine_swapchain->create_info.format; + WINE_TRACE("creating vkd3d-proton texture with dxgi format %d (%x)\n", + desc.Format, desc.Format); + desc.SampleDesc.Count = wine_swapchain->create_info.sampleCount; + desc.SampleDesc.Quality = 0; + desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + desc.Flags = 0; + if (!format_is_depth) + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + else + { + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + if (!(wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_SAMPLED_BIT)) + desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; + } + if (wine_swapchain->create_info.usageFlags & XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT) + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; + + our_d3d12 = heap_alloc_zero(sizeof(XrSwapchainImageD3D12KHR) * image_count); + for(i = 0; i < image_count; ++i) + { + hr = device_ext->lpVtbl->CreateResourceFromBorrowedHandle(device_ext, + &desc, our_vk[i].image, &our_d3d12[i].texture); + if(FAILED(hr)) + { + WINE_ERR("Failed to create vkd3d-proton texture from VkImage: %08x\n", hr); + succeeded = FALSE; + break; + } + WINE_TRACE("Successfully allocated texture %p\n", our_d3d12[i].texture); + } + device_ext->lpVtbl->Release(device_ext); + + wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d12; + if (!succeeded) + { + release_d3d12_resources(wine_swapchain, image_count); + heap_free(wine_swapchain->images); + wine_swapchain->images = NULL; + heap_free(our_vk); + return XR_ERROR_RUNTIME_FAILURE; + } } heap_free(our_vk); wine_swapchain->image_count = image_count; + WINE_TRACE("image count %d\n", image_count); } - to_copy = min(wine_swapchain->image_count, imageCapacityInput); *imageCountOutput = wine_swapchain->image_count; if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D11){ image_size = sizeof(XrSwapchainImageD3D11KHR); + } else if (wine_swapchain->wine_session->session_type == SESSION_TYPE_D3D12){ + image_size = sizeof(XrSwapchainImageD3D12KHR); } - memcpy(images, wine_swapchain->images, image_size * to_copy); + memcpy(images, wine_swapchain->images, image_size * min(wine_swapchain->image_count, imageCapacityInput)); return XR_SUCCESS; } @@ -1917,6 +2058,7 @@ XrResult WINAPI wine_xrEndFrame(XrSession session, const XrFrameEndInfo *frameEn wine_XrSession *wine_session = (wine_XrSession *)session; uint32_t i, view_idx = 0, view_info_idx = 0; IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; XrFrameEndInfo our_frameEndInfo; XrResult res; @@ -1946,9 +2088,16 @@ XrResult WINAPI wine_xrEndFrame(XrSession session, const XrFrameEndInfo *frameEn dxvk_device->lpVtbl->FlushRenderingCommands(dxvk_device); dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); } + else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) + { + WINE_TRACE("Locking vkd3d-proton submission queue.\n"); + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); + } res = xrEndFrame(((wine_XrSession *)session)->session, &our_frameEndInfo); if (dxvk_device) dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + else if (d3d12_device) + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); return res; } @@ -1976,6 +2125,10 @@ XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwap XrResult ret; WINE_TRACE("%p, %p, %p\n", swapchain, acquireInfo, index); + + if (wine_session->session_type == SESSION_TYPE_D3D12) + return XR_ERROR_RUNTIME_FAILURE; + if ((dxvk_device = wine_session->wine_instance->dxvk_device)) dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); ret = xrAcquireSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, acquireInfo, index); @@ -1991,6 +2144,10 @@ XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwap XrResult ret; WINE_TRACE("%p, %p\n", swapchain, releaseInfo); + + if (wine_session->session_type == SESSION_TYPE_D3D12) + return XR_ERROR_RUNTIME_FAILURE; + if ((dxvk_device = wine_session->wine_instance->dxvk_device)) dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); ret = xrReleaseSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, releaseInfo); diff --git a/wineopenxr/openxr_private.h b/wineopenxr/openxr_private.h index e110291d57..511b31ee41 100644 --- a/wineopenxr/openxr_private.h +++ b/wineopenxr/openxr_private.h @@ -20,6 +20,11 @@ typedef struct wine_XrInstance { XrSystemId systemId; IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; + ID3D12CommandQueue *d3d12_queue; + + VkDevice vk_device; + VkQueue vk_queue; } wine_XrInstance; union CompositionLayer; diff --git a/wineopenxr/vkd3d-proton-interop.h b/wineopenxr/vkd3d-proton-interop.h new file mode 100644 index 0000000000..34c2cb122f --- /dev/null +++ b/wineopenxr/vkd3d-proton-interop.h @@ -0,0 +1,186 @@ +/*** Partially copied from autogenerated header by WIDL 6.4 from ../src-vkd3d-proton/include/vkd3d_device_vkd3d_ext.idl ***/ + +#pragma once + +#include +#include + +#ifndef __ID3D12DeviceExt1_FWD_DEFINED__ +#define __ID3D12DeviceExt1_FWD_DEFINED__ +typedef interface ID3D12DeviceExt1 ID3D12DeviceExt1; +#endif + +#ifndef __ID3D12DXVKInteropDevice_FWD_DEFINED__ +#define __ID3D12DXVKInteropDevice_FWD_DEFINED__ +typedef interface ID3D12DXVKInteropDevice ID3D12DXVKInteropDevice; +#endif + +/***************************************************************************** + * ID3D12DeviceExt1 interface + */ +#ifndef __ID3D12DeviceExt1_INTERFACE_DEFINED__ +#define __ID3D12DeviceExt1_INTERFACE_DEFINED__ +typedef struct D3D12_UAV_INFO D3D12_UAV_INFO; +typedef struct D3D12_VK_EXTENSION D3D12_VK_EXTENSION; +typedef struct D3D12_CUBIN_DATA_HANDLE D3D12_CUBIN_DATA_HANDLE; + +DEFINE_GUID(IID_ID3D12DeviceExt1, 0x099a73fd, 0x2199, 0x4f45, 0xbf,0x48, 0x0e,0xb8,0x6f,0x6f,0xdb,0x65); +typedef struct ID3D12DeviceExt1Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ID3D12DeviceExt1 *This, + REFIID riid, + void **object); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ID3D12DeviceExt1 *This); + + ULONG (STDMETHODCALLTYPE *Release)( + ID3D12DeviceExt1 *This); + + /*** ID3D12DeviceExt methods ***/ + HRESULT (STDMETHODCALLTYPE *GetVulkanHandles)( + ID3D12DeviceExt1 *This, + VkInstance *vk_instance, + VkPhysicalDevice *vk_physical_device, + VkDevice *vk_device); + + BOOL (STDMETHODCALLTYPE *GetExtensionSupport)( + ID3D12DeviceExt1 *This, + D3D12_VK_EXTENSION extension); + + HRESULT (STDMETHODCALLTYPE *CreateCubinComputeShaderWithName)( + ID3D12DeviceExt1 *This, + const void *cubin_data, + UINT32 cubin_size, + UINT32 block_x, + UINT32 block_y, + UINT32 block_z, + const char *shader_name, + D3D12_CUBIN_DATA_HANDLE **handle); + + HRESULT (STDMETHODCALLTYPE *DestroyCubinComputeShader)( + ID3D12DeviceExt1 *This, + D3D12_CUBIN_DATA_HANDLE *handle); + + HRESULT (STDMETHODCALLTYPE *GetCudaTextureObject)( + ID3D12DeviceExt1 *This, + D3D12_CPU_DESCRIPTOR_HANDLE srv_handle, + D3D12_CPU_DESCRIPTOR_HANDLE sampler_handle, + UINT32 *cuda_texture_handle); + + HRESULT (STDMETHODCALLTYPE *GetCudaSurfaceObject)( + ID3D12DeviceExt1 *This, + D3D12_CPU_DESCRIPTOR_HANDLE uav_handle, + UINT32 *cuda_surface_handle); + + HRESULT (STDMETHODCALLTYPE *CaptureUAVInfo)( + ID3D12DeviceExt1 *This, + D3D12_UAV_INFO *uav_info); + + /*** ID3D12DeviceExt1 methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateResourceFromBorrowedHandle)( + ID3D12DeviceExt1 *This, + const D3D12_RESOURCE_DESC1 *desc, + UINT64 vk_handle, + ID3D12Resource **resource); + + HRESULT (STDMETHODCALLTYPE *GetVulkanQueueInfoEx)( + ID3D12DeviceExt1 *This, + ID3D12CommandQueue *queue, + VkQueue *vk_queue, + UINT32 *vk_queue_index, + UINT32 *vk_queue_flags, + UINT32 *vk_queue_family); + + END_INTERFACE +} ID3D12DeviceExt1Vtbl; + +interface ID3D12DeviceExt1 { + CONST_VTBL ID3D12DeviceExt1Vtbl* lpVtbl; +}; +#endif + +/***************************************************************************** + * ID3D12DXVKInteropDevice interface + */ +#ifndef __ID3D12DXVKInteropDevice_INTERFACE_DEFINED__ +#define __ID3D12DXVKInteropDevice_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ID3D12DXVKInteropDevice, 0x39da4e09, 0xbd1c, 0x4198, 0x9f,0xae, 0x86,0xbb,0xe3,0xbe,0x41,0xfd); +typedef struct ID3D12DXVKInteropDeviceVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ID3D12DXVKInteropDevice *This, + REFIID riid, + void **object); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ID3D12DXVKInteropDevice *This); + + ULONG (STDMETHODCALLTYPE *Release)( + ID3D12DXVKInteropDevice *This); + + /*** ID3D12DXVKInteropDevice methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDXGIAdapter)( + ID3D12DXVKInteropDevice *This, + REFIID iid, + void **object); + + HRESULT (STDMETHODCALLTYPE *GetInstanceExtensions)( + ID3D12DXVKInteropDevice *This, + UINT *extension_count, + const char **extensions); + + HRESULT (STDMETHODCALLTYPE *GetDeviceExtensions)( + ID3D12DXVKInteropDevice *This, + UINT *extension_count, + const char **extensions); + + HRESULT (STDMETHODCALLTYPE *GetDeviceFeatures)( + ID3D12DXVKInteropDevice *This, + const VkPhysicalDeviceFeatures2 **features); + + HRESULT (STDMETHODCALLTYPE *GetVulkanHandles)( + ID3D12DXVKInteropDevice *This, + VkInstance *vk_instance, + VkPhysicalDevice *vk_physical_device, + VkDevice *vk_device); + + HRESULT (STDMETHODCALLTYPE *GetVulkanQueueInfo)( + ID3D12DXVKInteropDevice *This, + ID3D12CommandQueue *queue, + VkQueue *vk_queue, + UINT32 *vk_queue_family); + + void (STDMETHODCALLTYPE *GetVulkanImageLayout)( + ID3D12DXVKInteropDevice *This, + ID3D12Resource *resource, + D3D12_RESOURCE_STATES state, + VkImageLayout *vk_layout); + + HRESULT (STDMETHODCALLTYPE *GetVulkanResourceInfo)( + ID3D12DXVKInteropDevice *This, + ID3D12Resource *resource, + UINT64 *vk_handle, + UINT64 *buffer_offset); + + HRESULT (STDMETHODCALLTYPE *LockCommandQueue)( + ID3D12DXVKInteropDevice *This, + ID3D12CommandQueue *queue); + + HRESULT (STDMETHODCALLTYPE *UnlockCommandQueue)( + ID3D12DXVKInteropDevice *This, + ID3D12CommandQueue *queue); + + END_INTERFACE +} ID3D12DXVKInteropDeviceVtbl; + +interface ID3D12DXVKInteropDevice { + CONST_VTBL ID3D12DXVKInteropDeviceVtbl* lpVtbl; +}; +#endif From 75c4f74e04c5f9285af48e7133f352a5dfbc2701 Mon Sep 17 00:00:00 2001 From: Yuxuan Shui Date: Thu, 9 May 2024 22:35:09 +0100 Subject: [PATCH 017/141] wineopenxr: Support acquiring/releasing images from D3D12 swapchains. --- wineopenxr/openxr.c | 206 ++++++++++++++++++++++++++++++++++-- wineopenxr/openxr_private.h | 26 +++++ 2 files changed, 221 insertions(+), 11 deletions(-) diff --git a/wineopenxr/openxr.c b/wineopenxr/openxr.c index cbc1bd949e..06942ad8aa 100644 --- a/wineopenxr/openxr.c +++ b/wineopenxr/openxr.c @@ -914,6 +914,7 @@ XrResult WINAPI wine_xrDestroyInstance(XrInstance instance) if (wine_instance->d3d12_device) { + wine_instance->p_vkDestroyCommandPool(wine_instance->vk_device, wine_instance->vk_command_pool, NULL); wine_instance->d3d12_device->lpVtbl->Release(wine_instance->d3d12_device); wine_instance->d3d12_queue->lpVtbl->Release(wine_instance->d3d12_queue); } @@ -1055,6 +1056,11 @@ XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateI case XR_TYPE_GRAPHICS_BINDING_D3D12_KHR: { const XrGraphicsBindingD3D12KHR *their_d3d12_binding = createInfo->next; + VkCommandPoolCreateInfo command_pool_create_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + .flags = 0, + .pNext = NULL, + }; HRESULT hr; UINT32 queue_index; VkQueueFlags queue_flags; @@ -1102,6 +1108,16 @@ XrResult WINAPI wine_xrCreateSession(XrInstance instance, const XrSessionCreateI our_create_info.next = &our_vk_binding; createInfo = &our_create_info; +#define X(proc) wine_instance->p_##proc = (void *)vkGetDeviceProcAddr(our_vk_binding.device, #proc); + VK_PROCS +#undef X + command_pool_create_info.queueFamilyIndex = our_vk_binding.queueFamilyIndex; + if (wine_instance->p_vkCreateCommandPool(wine_instance->vk_device, &command_pool_create_info, NULL, &wine_instance->vk_command_pool) != VK_SUCCESS) + { + WINE_WARN("vkCreateCommandPool failed\n"); + return XR_ERROR_RUNTIME_FAILURE; + } + session_type = SESSION_TYPE_D3D12; break; @@ -1723,6 +1739,7 @@ XrResult WINAPI wine_xrCreateSwapchain(XrSession session, const XrSwapchainCreat static void release_d3d12_resources(wine_XrSwapchain *wine_swapchain, uint32_t image_count) { + wine_XrInstance *wine_instance = wine_swapchain->wine_session->wine_instance; XrSwapchainImageD3D12KHR *d3d12_images = (XrSwapchainImageD3D12KHR *)wine_swapchain->images; UINT i; if (!image_count) @@ -1731,6 +1748,12 @@ static void release_d3d12_resources(wine_XrSwapchain *wine_swapchain, uint32_t i for (i = 0; i < image_count; i++) if (d3d12_images[i].texture) d3d12_images[i].texture->lpVtbl->Release(d3d12_images[i].texture); + wine_instance->p_vkFreeCommandBuffers(wine_instance->vk_device, wine_instance->vk_command_pool, image_count, wine_swapchain->cmd_release); + wine_instance->p_vkFreeCommandBuffers(wine_instance->vk_device, wine_instance->vk_command_pool, image_count, wine_swapchain->cmd_acquire); + heap_free(wine_swapchain->cmd_release); + heap_free(wine_swapchain->cmd_acquire); + heap_free(wine_swapchain->acquired); + heap_free(wine_swapchain->acquired_indices); } XrResult WINAPI wine_xrDestroySwapchain(XrSwapchain swapchain) @@ -1783,6 +1806,46 @@ static D3D11_USAGE d3d11usage_from_XrSwapchainUsageFlags(XrSwapchainUsageFlags f return ret; } +static VkResult record_transition_command(wine_XrInstance *instance, VkImage image, VkImageSubresourceRange subresource, + VkImageLayout from, VkImageLayout to, VkCommandBuffer *out_cmd) +{ + VkResult ret; + VkCommandBufferAllocateInfo command_buffer_allocate_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + .commandPool = instance->vk_command_pool, + .commandBufferCount = 1, + }; + VkCommandBufferBeginInfo begin_info = { + .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + .flags = 0, + }; + VkImageMemoryBarrier barrier = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + .oldLayout = from, + .newLayout = to, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = image, + .subresourceRange = subresource, + .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, + .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT, + }; + + *out_cmd = VK_NULL_HANDLE; + if (from == to){ + return VK_SUCCESS; + } + + if ((ret = instance->p_vkAllocateCommandBuffers(instance->vk_device, &command_buffer_allocate_info, out_cmd)) != VK_SUCCESS) + return ret; + if ((ret = instance->p_vkBeginCommandBuffer(*out_cmd, &begin_info)) != VK_SUCCESS) + return ret; + instance->p_vkCmdPipelineBarrier(*out_cmd, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + 0, 0, NULL, 0, NULL, 1, &barrier); + return instance->p_vkEndCommandBuffer(*out_cmd); +} + XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t imageCapacityInput, uint32_t *imageCountOutput, XrSwapchainImageBaseHeader *images) { wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; @@ -1857,6 +1920,16 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t HRESULT hr = wine_instance->d3d12_device->lpVtbl->QueryInterface(wine_instance->d3d12_device, &IID_ID3D12DeviceExt1, (void **)&device_ext); BOOL format_is_depth = is_vulkan_format_depth(map_format_dxgi_to_vulkan(wine_swapchain->create_info.format)); BOOL succeeded = TRUE; + const D3D12_RESOURCE_STATES incoming_state = format_is_depth ? D3D12_RESOURCE_STATE_DEPTH_WRITE : D3D12_RESOURCE_STATE_RENDER_TARGET; + const VkImageLayout vk_layout = format_is_depth ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + const VkImageSubresourceRange subresource = + { + .layerCount = wine_swapchain->create_info.arraySize, + .baseArrayLayer = 0, + .levelCount = wine_swapchain->create_info.mipCount, + .baseMipLevel = 0, + .aspectMask = format_is_depth ? (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) : VK_IMAGE_ASPECT_COLOR_BIT, + }; if (FAILED(hr)) { WINE_ERR("Cannot get vkd3d-proton interface: %08x\n", hr); @@ -1902,7 +1975,28 @@ XrResult WINAPI wine_xrEnumerateSwapchainImages(XrSwapchain swapchain, uint32_t } device_ext->lpVtbl->Release(device_ext); - wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d12; + if (succeeded) + { + wine_swapchain->acquired = heap_alloc_zero(sizeof(BOOL) * image_count); + wine_swapchain->acquired_indices = heap_alloc(sizeof(uint32_t) * (image_count + 1)); + wine_swapchain->acquired_count = wine_swapchain->acquired_start = 0; + wine_swapchain->images = (XrSwapchainImageBaseHeader *)our_d3d12; + + wine_swapchain->cmd_release = heap_alloc_zero(sizeof(VkCommandBuffer) * image_count); + wine_swapchain->cmd_acquire = heap_alloc_zero(sizeof(VkCommandBuffer) * image_count); + for (i = 0; i < image_count; i++) + { + VkImageLayout d3d12_vk_layout; + wine_instance->d3d12_device->lpVtbl->GetVulkanImageLayout(wine_instance->d3d12_device, our_d3d12[i].texture, incoming_state, &d3d12_vk_layout); + if (record_transition_command(wine_instance, our_vk[i].image, subresource, d3d12_vk_layout, vk_layout, &wine_swapchain->cmd_release[i]) != VK_SUCCESS || + record_transition_command(wine_instance, our_vk[i].image, subresource, vk_layout, d3d12_vk_layout, &wine_swapchain->cmd_acquire[i]) != VK_SUCCESS) + { + WINE_ERR("Failed to create command buffer for layout transition\n"); + succeeded = FALSE; + break; + } + } + } if (!succeeded) { release_d3d12_resources(wine_swapchain, image_count); @@ -2106,53 +2200,143 @@ XrResult WINAPI wine_xrBeginFrame(XrSession session, const XrFrameBeginInfo *fra { wine_XrSession *wine_session = (wine_XrSession *)session; IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; XrResult ret; WINE_TRACE("%p, %p\n", session, frameBeginInfo); if ((dxvk_device = wine_session->wine_instance->dxvk_device)) dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); ret = xrBeginFrame(((wine_XrSession *)session)->session, frameBeginInfo); if (dxvk_device) dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + else if (d3d12_device) + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); return ret; } XrResult WINAPI wine_xrAcquireSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageAcquireInfo *acquireInfo, uint32_t *index) { - wine_XrSession *wine_session = ((wine_XrSwapchain *)swapchain)->wine_session; + wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; + wine_XrSession *wine_session = wine_swapchain->wine_session; IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device; XrResult ret; - WINE_TRACE("%p, %p, %p\n", swapchain, acquireInfo, index); - - if (wine_session->session_type == SESSION_TYPE_D3D12) - return XR_ERROR_RUNTIME_FAILURE; + WINE_TRACE("%p, %p, %p image count %d, acquired %d\n", swapchain, acquireInfo, index, wine_swapchain->image_count, + wine_swapchain->acquired_count); if ((dxvk_device = wine_session->wine_instance->dxvk_device)) dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + else if ((d3d12_device = wine_session->wine_instance->d3d12_device)) + { + if (wine_swapchain->acquired_count >= wine_swapchain->image_count) + { + WINE_WARN("Application has acquired all images but still tries to acquire more.\n"); + return XR_ERROR_CALL_ORDER_INVALID; + } + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); + } ret = xrAcquireSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, acquireInfo, index); if (dxvk_device) + { dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + return ret; + } + + if (!d3d12_device) + return ret; + + if (ret == XR_SUCCESS) + { + if (!wine_swapchain->acquired[*index] && wine_swapchain->cmd_acquire[*index] != VK_NULL_HANDLE) + { + VkSubmitInfo submit_info = + { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_acquire[*index], + }; + + wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + if (!wine_swapchain->acquired[*index]) + { + uint32_t next = (wine_swapchain->acquired_start + wine_swapchain->acquired_count) % wine_swapchain->image_count; + wine_swapchain->acquired[*index] = TRUE; + wine_swapchain->acquired_indices[next] = *index; + wine_swapchain->acquired_count += 1; + } + else + WINE_WARN("the application acquired the same image (index %d) again!?", *index); + } + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); return ret; } XrResult WINAPI wine_xrReleaseSwapchainImage(XrSwapchain swapchain, const XrSwapchainImageReleaseInfo *releaseInfo) { - wine_XrSession *wine_session = ((wine_XrSwapchain *)swapchain)->wine_session; + wine_XrSwapchain *wine_swapchain = (wine_XrSwapchain *)swapchain; + wine_XrSession *wine_session = wine_swapchain->wine_session; IDXGIVkInteropDevice2 *dxvk_device; + ID3D12DXVKInteropDevice *d3d12_device = wine_session->wine_instance->d3d12_device; XrResult ret; + uint32_t index; WINE_TRACE("%p, %p\n", swapchain, releaseInfo); - - if (wine_session->session_type == SESSION_TYPE_D3D12) - return XR_ERROR_RUNTIME_FAILURE; - if ((dxvk_device = wine_session->wine_instance->dxvk_device)) dxvk_device->lpVtbl->LockSubmissionQueue(dxvk_device); + else if (d3d12_device) + { + if (wine_swapchain->acquired_count == 0) + { + WINE_WARN("Application tried to release a swapchain image without having acquired it first.\n"); + return XR_ERROR_CALL_ORDER_INVALID; + } + + d3d12_device->lpVtbl->LockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); + + index = wine_swapchain->acquired_indices[wine_swapchain->acquired_start]; + if (wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) + { + VkSubmitInfo submit_info = + { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_release[index], + }; + + wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + } ret = xrReleaseSwapchainImage(((wine_XrSwapchain *)swapchain)->swapchain, releaseInfo); if (dxvk_device) + { dxvk_device->lpVtbl->ReleaseSubmissionQueue(dxvk_device); + return ret; + } + if (!d3d12_device) + return ret; + if (ret != XR_SUCCESS && wine_swapchain->cmd_release[index] != VK_NULL_HANDLE) + { + VkSubmitInfo submit_info = + { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + .pCommandBuffers = &wine_swapchain->cmd_acquire[index], + }; + WINE_WARN("xrReleaseSwapchainImage failed, reverting layout transition\n"); + wine_session->wine_instance->p_vkQueueSubmit(wine_session->wine_instance->vk_queue, 1, &submit_info, VK_NULL_HANDLE); + } + if (ret == XR_SUCCESS) + { + wine_swapchain->acquired[index] = FALSE; + wine_swapchain->acquired_start = (wine_swapchain->acquired_start + 1) % wine_swapchain->image_count; + wine_swapchain->acquired_count -= 1; + } + d3d12_device->lpVtbl->UnlockCommandQueue(d3d12_device, wine_session->wine_instance->d3d12_queue); return ret; } diff --git a/wineopenxr/openxr_private.h b/wineopenxr/openxr_private.h index 511b31ee41..8cfada59f7 100644 --- a/wineopenxr/openxr_private.h +++ b/wineopenxr/openxr_private.h @@ -9,6 +9,22 @@ struct IDXGIVkInteropDevice2; typedef struct IDXGIVkInteropDevice2 IDXGIVkInteropDevice2; +typedef struct ID3D12DXVKInteropDevice ID3D12DXVKInteropDevice; + +#define VK_PROCS \ + X(vkAllocateCommandBuffers) \ + X(vkBeginCommandBuffer) \ + X(vkEndCommandBuffer) \ + X(vkQueueSubmit) \ + X(vkQueueWaitIdle) \ + X(vkFreeCommandBuffers) \ + X(vkCmdPipelineBarrier) \ + X(vkCreateCommandPool) \ + X(vkDestroyCommandPool) \ + X(vkDestroyFence) \ + X(vkCreateFence) \ + X(vkWaitForFences) \ + X(vkResetFences) typedef struct wine_XrInstance { XrInstance instance; @@ -23,8 +39,13 @@ typedef struct wine_XrInstance { ID3D12DXVKInteropDevice *d3d12_device; ID3D12CommandQueue *d3d12_queue; + /* For layout transitions for vkd3d-proton */ +#define X(proc) PFN_##proc p_##proc; + VK_PROCS +#undef X VkDevice vk_device; VkQueue vk_queue; + VkCommandPool vk_command_pool; } wine_XrInstance; union CompositionLayer; @@ -56,9 +77,14 @@ typedef struct wine_XrSwapchain{ XrSwapchain swapchain; XrSwapchainImageBaseHeader *images; uint32_t image_count; + uint32_t acquired_count, acquired_start; + BOOL *acquired; + uint32_t *acquired_indices; struct wine_XrSession *wine_session; XrSwapchainCreateInfo create_info; + VkCommandBuffer *cmd_release; + VkCommandBuffer *cmd_acquire; } wine_XrSwapchain; struct openxr_func { From 2eb602e161a15555c9a4bb1795061e48cb2abe48 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Fri, 31 May 2024 13:20:45 -0600 Subject: [PATCH 018/141] lsteamclient: Use default conversion in convert_callback_utow / callback_message_utow even if Unix len is unknown. CW-Bug-Id: #23875 --- lsteamclient/unixlib.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/lsteamclient/unixlib.cpp b/lsteamclient/unixlib.cpp index 97de6fcd86..1ca02ced13 100644 --- a/lsteamclient/unixlib.cpp +++ b/lsteamclient/unixlib.cpp @@ -805,8 +805,7 @@ void convert_callback_utow(int id, void *u_callback, int u_callback_len, void *w if (!best) { ERR( "Could not find id %d, u_callback_len %d, w_callback_len %d.\n", id, u_callback_len, w_callback_len ); - memcpy( w_callback, u_callback, std::min(w_callback_len, u_callback_len) ); - return; + best = find_first_callback_def_by_id( id ); } if (best->w_callback_len != w_callback_len || best->u_callback_len != u_callback_len) @@ -835,7 +834,10 @@ void callback_message_utow( const u_CallbackMsg_t *u_msg, w_CallbackMsg_t *w_msg ++c; } if (c == end || c->id != u_msg->m_iCallback) - WARN( "Unix len %d not found for callback %d.\n", u_msg->m_cubParam, u_msg->m_iCallback ); + { + ERR( "Unix len %d not found for callback %d.\n", u_msg->m_cubParam, u_msg->m_iCallback ); + len = find_first_callback_def_by_id( u_msg->m_iCallback )->w_callback_len; + } } w_msg->m_hSteamUser = u_msg->m_hSteamUser; From 874adce46c5812e46ffea56164155b4aea57727e Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Mon, 3 Jun 2024 11:46:37 -0600 Subject: [PATCH 019/141] proton: Disable GL_ARB_bindless_texture for Zaccaria Pinball. CW-Bug-Id: #23874 --- proton | 3 +++ 1 file changed, 3 insertions(+) diff --git a/proton b/proton index 30af9be197..7a2b25f4e8 100755 --- a/proton +++ b/proton @@ -1381,6 +1381,9 @@ class Session: #nvidia override self.env["__GL_ExtensionStringVersion"] = "17700" + if os.environ.get("SteamGameId", 0) == "444930": + self.env["MESA_EXTENSION_OVERRIDE"] = "-GL_ARB_bindless_texture" + if "forcelgadd" in self.compat_config: self.env["WINE_LARGE_ADDRESS_AWARE"] = "1" else: From c6a77ac810b6b74d5d3f9594b533db24752a6b63 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Tue, 4 Jun 2024 11:22:28 -0500 Subject: [PATCH 020/141] proton: Enable gamedrive compat option for Yakuza Kiwami CW-Bug-Id: #22421 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 7a2b25f4e8..8d7fa2d021 100755 --- a/proton +++ b/proton @@ -1092,6 +1092,7 @@ def default_compat_config(): "2371630", #Sword Art Online: Integral Factor "460790", #Bayonetta "273590", #Descent 3 + "834530", #Yakuza Kiwami ]: ret.add("gamedrive") From ce441b0ecbe2665d342ab93069578ef71b3c8337 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 28 Mar 2024 12:46:15 +0100 Subject: [PATCH 021/141] build: Run make_specfiles after make_vulkan. No-op but make_specfiles reads .specs and make_vulkan updates one. --- Makefile.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index bbbef5eee4..70abdfb289 100644 --- a/Makefile.in +++ b/Makefile.in @@ -498,9 +498,9 @@ $(eval $(call rules-autoconf,wine,32)) $(eval $(call rules-autoconf,wine,64)) $(OBJ)/.wine-post-source: - -cd $(WINE_SRC) && tools/make_specfiles cd $(WINE_SRC) && tools/make_requests cd $(WINE_SRC) && dlls/winevulkan/make_vulkan -x vk.xml + -cd $(WINE_SRC) && tools/make_specfiles touch $@ $(OBJ)/.wine-post-build64: From b3ad21ed9242997198ecc49b702406abdbc7e9c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 28 Mar 2024 12:46:55 +0100 Subject: [PATCH 022/141] build: Ignore make_specfiles generated sources. --- Makefile.in | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index 70abdfb289..889fc84546 100644 --- a/Makefile.in +++ b/Makefile.in @@ -476,7 +476,9 @@ WINE_SOURCE_ARGS = \ --exclude dlls/winevulkan/vulkan_thunks.c \ --exclude dlls/winevulkan/vulkan_thunks.h \ --exclude dlls/winevulkan/winevulkan.json \ - --exclude dlls/winevulkan/winevulkan.spec + --exclude dlls/winevulkan/winevulkan.spec \ + --exclude dlls/ntdll/ntsyscalls.h \ + --exclude dlls/win32u/win32syscalls.h \ WINE_CONFIGURE_ARGS = \ --enable-werror \ From 331f00b76bbb88846a7a2aef07be9ba1d7bf1e39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 28 Mar 2024 12:48:33 +0100 Subject: [PATCH 023/141] build: Add rules to generate wine requests. --- Makefile.in | 6 +++++- make/rules-wine-requests.mk | 30 ++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 make/rules-wine-requests.mk diff --git a/Makefile.in b/Makefile.in index 889fc84546..e67d0b62ba 100644 --- a/Makefile.in +++ b/Makefile.in @@ -96,6 +96,7 @@ include $(SRC)/make/rules-cmake.mk include $(SRC)/make/rules-autoconf.mk include $(SRC)/make/rules-configure.mk include $(SRC)/make/rules-winemaker.mk +include $(SRC)/make/rules-wine-requests.mk include $(SRC)/make/rules-cargo.mk @@ -479,6 +480,9 @@ WINE_SOURCE_ARGS = \ --exclude dlls/winevulkan/winevulkan.spec \ --exclude dlls/ntdll/ntsyscalls.h \ --exclude dlls/win32u/win32syscalls.h \ + --exclude include/wine/server_protocol.h \ + --exclude server/request.h \ + --exclude server/trace.c \ WINE_CONFIGURE_ARGS = \ --enable-werror \ @@ -498,9 +502,9 @@ WINE_DEPENDS = gst_orc gstreamer gst_base vkd3d openfst kaldi vosk $(eval $(call rules-source,wine,$(SRCDIR)/wine)) $(eval $(call rules-autoconf,wine,32)) $(eval $(call rules-autoconf,wine,64)) +$(eval $(call rules-wine-requests,wine)) $(OBJ)/.wine-post-source: - cd $(WINE_SRC) && tools/make_requests cd $(WINE_SRC) && dlls/winevulkan/make_vulkan -x vk.xml -cd $(WINE_SRC) && tools/make_specfiles touch $@ diff --git a/make/rules-wine-requests.mk b/make/rules-wine-requests.mk new file mode 100644 index 0000000000..4244fdac41 --- /dev/null +++ b/make/rules-wine-requests.mk @@ -0,0 +1,30 @@ +# parameters: +# $(1): lowercase package name +# $(2): uppercase package name +# +define create-rules-wine-requests +$$($(2)_SRC)/include/wine/server_protocol.h: | $$(OBJ)/.$(1)-post-source +$$($(2)_SRC)/include/wine/server_protocol.h: $$($(2)_ORIGIN)/include/wine/server_protocol.h + cp -a $$< $$@ +$$($(2)_SRC)/server/request.h: | $$(OBJ)/.$(1)-post-source +$$($(2)_SRC)/server/request.h: $$($(2)_ORIGIN)/server/request.h + cp -a $$< $$@ +$$($(2)_SRC)/server/trace.c: | $$(OBJ)/.$(1)-post-source +$$($(2)_SRC)/server/trace.c: $$($(2)_ORIGIN)/server/trace.c + cp -a $$< $$@ + +$$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/include/wine/server_protocol.h +$$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/server/request.h +$$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/server/trace.c +$$(OBJ)/.$(1)-wine-requests: $$($(2)_ORIGIN)/server/protocol.def +$$(OBJ)/.$(1)-wine-requests: $$($(2)_ORIGIN)/tools/make_requests +$$(OBJ)/.$(1)-wine-requests: | $$(OBJ)/.$(1)-post-source + @echo ":: wine-requesting $(1)..." >&2 + cd "$$($(2)_SRC)" && tools/make_requests + touch $$@ + +$$(OBJ)/.$(1)-build32: $$(OBJ)/.$(1)-wine-requests +$$(OBJ)/.$(1)-build64: $$(OBJ)/.$(1)-wine-requests +endef + +rules-wine-requests = $(call create-rules-wine-requests,$(1),$(call toupper,$(1))) From be13c8dca36fb7e5a9f1cc04de40c6fe4b228902 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 28 Mar 2024 12:53:30 +0100 Subject: [PATCH 024/141] build: Ignore dxvk version.h.in changes. --- Makefile.in | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Makefile.in b/Makefile.in index e67d0b62ba..f04d41362f 100644 --- a/Makefile.in +++ b/Makefile.in @@ -545,6 +545,9 @@ $(eval $(call rules-makedep,vrclient,64)) DXVK_SOURCE_DATE_EPOCH32 := $(shell expr $(BASE_SOURCE_DATE_EPOCH32) - 1) DXVK_SOURCE_DATE_EPOCH64 := $(shell expr $(BASE_SOURCE_DATE_EPOCH64) - 1) +DXVK_SOURCE_ARGS = \ + --exclude version.h.in \ + DXVK_MESON_ARGS32 = --bindir=$(DXVK_DST32)/lib/wine/dxvk DXVK_MESON_ARGS64 = --bindir=$(DXVK_DST64)/lib64/wine/dxvk DXVK_DEPENDS = glslang From bba7fe6fa7f3907f16b5aa0ff5d5b9d72f3a2741 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Mon, 10 Jun 2024 11:26:28 +0200 Subject: [PATCH 025/141] build: Add dependencies for makedep to find generated server headers. --- make/rules-wine-requests.mk | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/make/rules-wine-requests.mk b/make/rules-wine-requests.mk index 4244fdac41..26801ebb48 100644 --- a/make/rules-wine-requests.mk +++ b/make/rules-wine-requests.mk @@ -13,6 +13,14 @@ $$($(2)_SRC)/server/trace.c: | $$(OBJ)/.$(1)-post-source $$($(2)_SRC)/server/trace.c: $$($(2)_ORIGIN)/server/trace.c cp -a $$< $$@ +$$(OBJ)/.$(1)-configure32: $$($(2)_SRC)/include/wine/server_protocol.h +$$(OBJ)/.$(1)-configure32: $$($(2)_SRC)/server/request.h +$$(OBJ)/.$(1)-configure32: $$($(2)_SRC)/server/trace.c + +$$(OBJ)/.$(1)-configure64: $$($(2)_SRC)/include/wine/server_protocol.h +$$(OBJ)/.$(1)-configure64: $$($(2)_SRC)/server/request.h +$$(OBJ)/.$(1)-configure64: $$($(2)_SRC)/server/trace.c + $$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/include/wine/server_protocol.h $$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/server/request.h $$(OBJ)/.$(1)-wine-requests: $$($(2)_SRC)/server/trace.c From 95f865dafdca4a04f13a1e8237122fad790e24f9 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 12 Jun 2024 18:36:25 -0600 Subject: [PATCH 026/141] proton: Prefer native ddraw for Arcanum (500810). CW-Bug-Id: #23916 --- proton | 3 +++ 1 file changed, 3 insertions(+) diff --git a/proton b/proton index 8d7fa2d021..91b6c2e233 100755 --- a/proton +++ b/proton @@ -1385,6 +1385,9 @@ class Session: if os.environ.get("SteamGameId", 0) == "444930": self.env["MESA_EXTENSION_OVERRIDE"] = "-GL_ARB_bindless_texture" + if os.environ.get("SteamGameId", 0) == "500810": + self.dlloverrides["ddraw"] = "n,b" + if "forcelgadd" in self.compat_config: self.env["WINE_LARGE_ADDRESS_AWARE"] = "1" else: From ba761f8af442de6fd37571f6eb5b25efa00bdc60 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 13 Jun 2024 12:22:33 -0600 Subject: [PATCH 027/141] proton: Enable gamedrive early for Bad Mojo Redux. CW-Bug-Id: #23924 --- proton | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/proton b/proton index 91b6c2e233..345b17cca0 100755 --- a/proton +++ b/proton @@ -1160,6 +1160,11 @@ def default_compat_config(): ]: ret.add("xalia") + if appid in [ + "255960", #Bad Mojo Redux + ]: + ret.add("gamedrive") + return ret default_cpu_limit = { From 7cd7fe06cebf5ea335f974ababb8895604c43a31 Mon Sep 17 00:00:00 2001 From: Giovanni Mascellani Date: Wed, 26 Jun 2024 14:56:14 +0200 Subject: [PATCH 028/141] make: Canonicalize ORIGIN paths. That path can be relative when the build directory is inside the Proton source directory. Since it then used to patch compile_commands.json, it is important that it is absolute, otherwise it implicitly becomes grafted to a directory for which it is meaningless. --- make/rules-source.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/make/rules-source.mk b/make/rules-source.mk index f9257df102..70352bac40 100644 --- a/make/rules-source.mk +++ b/make/rules-source.mk @@ -15,7 +15,7 @@ # define create-rules-source $(2)_SRC = $$(OBJ)/src-$(1) -$(2)_ORIGIN = $(3) +$(2)_ORIGIN = $(realpath $(3)) $(1)-rebuild: .PHONY: $(1)-rebuild From fced277adf17faf73178be84dbf32f80ad3e30aa Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 26 Jun 2024 19:19:11 -0600 Subject: [PATCH 029/141] lsteamclient: Fix source length for ntdll_umbstowcs(). CW-Bug-Id: #23962 --- lsteamclient/unixlib.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lsteamclient/unixlib.cpp b/lsteamclient/unixlib.cpp index 1ca02ced13..8d4fdbea39 100644 --- a/lsteamclient/unixlib.cpp +++ b/lsteamclient/unixlib.cpp @@ -561,7 +561,7 @@ char *steamclient_dos_to_unix_path( const char *src, int is_url ) uint32_t r; if (is_url) while (*src == '/') ++src; - r = ntdll_umbstowcs( src, -1, srcW + 4, PATH_MAX - 4 ); + r = ntdll_umbstowcs( src, strlen( src ) + 1, srcW + 4, PATH_MAX - 4 ); if (r == 0) unix_path = NULL; else { @@ -628,7 +628,7 @@ const char **steamclient_dos_to_unix_path_array( const char **src ) TRACE( " src[%zu] %s\n", s - src, debugstr_a(*s) ); if (IS_ABSOLUTE( *s )) { - ntdll_umbstowcs( *s, -1, scratch + 4, PATH_MAX - 4 ); + ntdll_umbstowcs( *s, strlen( *s ) + 1, scratch + 4, PATH_MAX - 4 ); collapse_path( scratch, 4 ); *o = get_unix_file_name( scratch ); } From a2ca4a818106c8db68263abff05749496127c7f2 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 26 Jun 2024 19:24:41 -0600 Subject: [PATCH 030/141] vrclient_x64: Fix source length for ntdll_umbstowcs(). CW-Bug-Id: #23962 --- vrclient_x64/json_converter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrclient_x64/json_converter.cpp b/vrclient_x64/json_converter.cpp index 7d6b4f66bb..aa1573b998 100644 --- a/vrclient_x64/json_converter.cpp +++ b/vrclient_x64/json_converter.cpp @@ -72,7 +72,7 @@ char *vrclient_dos_to_unix_path( const char *src ) char *unix_path; uint32_t r; - r = ntdll_umbstowcs( src, -1, srcW + 4, PATH_MAX - 4 ); + r = ntdll_umbstowcs( src, strlen( src ) + 1, srcW + 4, PATH_MAX - 4 ); if (r == 0) unix_path = NULL; else { @@ -182,7 +182,7 @@ static bool convert_path_to_win(std::string &s) char *unix_path; uint32_t sz; - sz = ntdll_umbstowcs( s.c_str(), -1, srcW + 4, PATH_MAX - 4 ); + sz = ntdll_umbstowcs( s.c_str(), strlen( s.c_str() ) + 1, srcW + 4, PATH_MAX - 4 ); if (!sz) return false; for (tmp = srcW; *tmp; ++tmp) if (*tmp == '/') *tmp = '\\'; From 73b9af8d6b69e3f5d2a86202f2f47e0f27d41762 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 27 Jun 2024 17:26:38 +0200 Subject: [PATCH 031/141] lsteamclient: Import SteamWorks SDK 1.60. CW-Bug-Id: #23976 --- lsteamclient/steamworks_sdk_160/isteamapps.h | 201 ++ .../steamworks_sdk_160/isteamappticket.h | 28 + .../steamworks_sdk_160/isteamclient.h | 173 ++ .../steamworks_sdk_160/isteamcontroller.h | 726 +++++++ .../steamworks_sdk_160/isteamdualsense.h | 169 ++ .../steamworks_sdk_160/isteamfriends.h | 757 +++++++ .../isteamgamecoordinator.h | 74 + .../steamworks_sdk_160/isteamgameserver.h | 394 ++++ .../isteamgameserverstats.h | 114 + .../steamworks_sdk_160/isteamhtmlsurface.h | 479 +++++ lsteamclient/steamworks_sdk_160/isteamhttp.h | 219 ++ lsteamclient/steamworks_sdk_160/isteaminput.h | 982 +++++++++ .../steamworks_sdk_160/isteaminventory.h | 435 ++++ .../steamworks_sdk_160/isteammatchmaking.h | 1087 ++++++++++ lsteamclient/steamworks_sdk_160/isteammusic.h | 71 + .../steamworks_sdk_160/isteammusicremote.h | 133 ++ .../steamworks_sdk_160/isteamnetworking.h | 343 +++ .../isteamnetworkingmessages.h | 197 ++ .../isteamnetworkingsockets.h | 1029 +++++++++ .../isteamnetworkingutils.h | 503 +++++ .../isteamparentalsettings.h | 65 + .../isteamps3overlayrenderer.h | 91 + .../steamworks_sdk_160/isteamremoteplay.h | 99 + .../steamworks_sdk_160/isteamremotestorage.h | 661 ++++++ .../steamworks_sdk_160/isteamscreenshots.h | 120 ++ .../steamworks_sdk_160/isteamtimeline.h | 118 ++ lsteamclient/steamworks_sdk_160/isteamugc.h | 632 ++++++ lsteamclient/steamworks_sdk_160/isteamuser.h | 439 ++++ .../steamworks_sdk_160/isteamuserstats.h | 487 +++++ lsteamclient/steamworks_sdk_160/isteamutils.h | 343 +++ lsteamclient/steamworks_sdk_160/isteamvideo.h | 67 + .../steamworks_sdk_160/matchmakingtypes.h | 231 ++ lsteamclient/steamworks_sdk_160/steam_api.h | 266 +++ .../steamworks_sdk_160/steam_api_common.h | 249 +++ .../steamworks_sdk_160/steam_api_flat.h | 1286 +++++++++++ .../steamworks_sdk_160/steam_api_internal.h | 338 +++ .../steamworks_sdk_160/steam_gameserver.h | 137 ++ .../steamworks_sdk_160/steamclientpublic.h | 1198 +++++++++++ .../steamencryptedappticket.h | 40 + .../steamworks_sdk_160/steamhttpenums.h | 105 + .../steamnetworkingfakeip.h | 135 ++ .../steamworks_sdk_160/steamnetworkingtypes.h | 1880 +++++++++++++++++ .../steamworks_sdk_160/steamps3params.h | 112 + lsteamclient/steamworks_sdk_160/steamtypes.h | 156 ++ .../steamworks_sdk_160/steamuniverse.h | 27 + 45 files changed, 17396 insertions(+) create mode 100644 lsteamclient/steamworks_sdk_160/isteamapps.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamappticket.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamclient.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamcontroller.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamdualsense.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamfriends.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamgamecoordinator.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamgameserver.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamgameserverstats.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamhtmlsurface.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamhttp.h create mode 100644 lsteamclient/steamworks_sdk_160/isteaminput.h create mode 100644 lsteamclient/steamworks_sdk_160/isteaminventory.h create mode 100644 lsteamclient/steamworks_sdk_160/isteammatchmaking.h create mode 100644 lsteamclient/steamworks_sdk_160/isteammusic.h create mode 100644 lsteamclient/steamworks_sdk_160/isteammusicremote.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamnetworking.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamnetworkingmessages.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamnetworkingsockets.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamnetworkingutils.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamparentalsettings.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamps3overlayrenderer.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamremoteplay.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamremotestorage.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamscreenshots.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamtimeline.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamugc.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamuser.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamuserstats.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamutils.h create mode 100644 lsteamclient/steamworks_sdk_160/isteamvideo.h create mode 100644 lsteamclient/steamworks_sdk_160/matchmakingtypes.h create mode 100644 lsteamclient/steamworks_sdk_160/steam_api.h create mode 100644 lsteamclient/steamworks_sdk_160/steam_api_common.h create mode 100644 lsteamclient/steamworks_sdk_160/steam_api_flat.h create mode 100644 lsteamclient/steamworks_sdk_160/steam_api_internal.h create mode 100644 lsteamclient/steamworks_sdk_160/steam_gameserver.h create mode 100644 lsteamclient/steamworks_sdk_160/steamclientpublic.h create mode 100644 lsteamclient/steamworks_sdk_160/steamencryptedappticket.h create mode 100644 lsteamclient/steamworks_sdk_160/steamhttpenums.h create mode 100644 lsteamclient/steamworks_sdk_160/steamnetworkingfakeip.h create mode 100644 lsteamclient/steamworks_sdk_160/steamnetworkingtypes.h create mode 100644 lsteamclient/steamworks_sdk_160/steamps3params.h create mode 100644 lsteamclient/steamworks_sdk_160/steamtypes.h create mode 100644 lsteamclient/steamworks_sdk_160/steamuniverse.h diff --git a/lsteamclient/steamworks_sdk_160/isteamapps.h b/lsteamclient/steamworks_sdk_160/isteamapps.h new file mode 100644 index 0000000000..c47b18397e --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamapps.h @@ -0,0 +1,201 @@ +//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to app data in Steam +// +//============================================================================= + +#ifndef ISTEAMAPPS_H +#define ISTEAMAPPS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +const int k_cubAppProofOfPurchaseKeyMax = 240; // max supported length of a legacy cd key + + +//----------------------------------------------------------------------------- +// Purpose: interface to app data +//----------------------------------------------------------------------------- +class ISteamApps +{ +public: + virtual bool BIsSubscribed() = 0; + virtual bool BIsLowViolence() = 0; + virtual bool BIsCybercafe() = 0; + virtual bool BIsVACBanned() = 0; + virtual const char *GetCurrentGameLanguage() = 0; + virtual const char *GetAvailableGameLanguages() = 0; + + // only use this member if you need to check ownership of another game related to yours, a demo for example + virtual bool BIsSubscribedApp( AppId_t appID ) = 0; + + // Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed + virtual bool BIsDlcInstalled( AppId_t appID ) = 0; + + // returns the Unix time of the purchase of the app + virtual uint32 GetEarliestPurchaseUnixTime( AppId_t nAppID ) = 0; + + // Checks if the user is subscribed to the current app through a free weekend + // This function will return false for users who have a retail or other type of license + // Before using, please ask your Valve technical contact how to package and secure your free weekened + virtual bool BIsSubscribedFromFreeWeekend() = 0; + + // Returns the number of DLC pieces for the running app + virtual int GetDLCCount() = 0; + + // Returns metadata for DLC by index, of range [0, GetDLCCount()] + virtual bool BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize ) = 0; + + // Install/Uninstall control for optional DLC + virtual void InstallDLC( AppId_t nAppID ) = 0; + virtual void UninstallDLC( AppId_t nAppID ) = 0; + + // Request legacy cd-key for yourself or owned DLC. If you are interested in this + // data then make sure you provide us with a list of valid keys to be distributed + // to users when they purchase the game, before the game ships. + // You'll receive an AppProofOfPurchaseKeyResponse_t callback when + // the key is available (which may be immediately). + virtual void RequestAppProofOfPurchaseKey( AppId_t nAppID ) = 0; + + virtual bool GetCurrentBetaName( char *pchName, int cchNameBufferSize ) = 0; // returns current beta branch name, 'public' is the default branch + virtual bool MarkContentCorrupt( bool bMissingFilesOnly ) = 0; // signal Steam that game files seems corrupt or missing + virtual uint32 GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots ) = 0; // return installed depots in mount order + + // returns current app install folder for AppID, returns folder name length + virtual uint32 GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize ) = 0; + virtual bool BIsAppInstalled( AppId_t appID ) = 0; // returns true if that app is installed (not necessarily owned) + + // returns the SteamID of the original owner. If this CSteamID is different from ISteamUser::GetSteamID(), + // the user has a temporary license borrowed via Family Sharing + virtual CSteamID GetAppOwner() = 0; + + // Returns the associated launch param if the game is run via steam://run///?param1=value1¶m2=value2¶m3=value3 etc. + // Parameter names starting with the character '@' are reserved for internal use and will always return and empty string. + // Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game, + // but it is advised that you not param names beginning with an underscore for your own features. + // Check for new launch parameters on callback NewUrlLaunchParameters_t + virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0; + + // get download progress for optional DLC + virtual bool GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0; + + // return the buildid of this app, may change at any time based on backend updates to the game + virtual int GetAppBuildId() = 0; + + // Request all proof of purchase keys for the calling appid and associated DLC. + // A series of AppProofOfPurchaseKeyResponse_t callbacks will be sent with + // appropriate appid values, ending with a final callback where the m_nAppId + // member is k_uAppIdInvalid (zero). + virtual void RequestAllProofOfPurchaseKeys() = 0; + + STEAM_CALL_RESULT( FileDetailsResult_t ) + virtual SteamAPICall_t GetFileDetails( const char* pszFileName ) = 0; + + // Get command line if game was launched via Steam URL, e.g. steam://run////. + // This method of passing a connect string (used when joining via rich presence, accepting an + // invite, etc) is preferable to passing the connect string on the operating system command + // line, which is a security risk. In order for rich presence joins to go through this + // path and not be placed on the OS command line, you must set a value in your app's + // configuration on Steam. Ask Valve for help with this. + // + // If game was already running and launched again, the NewUrlLaunchParameters_t will be fired. + virtual int GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine ) = 0; + + // Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID + virtual bool BIsSubscribedFromFamilySharing() = 0; + + // check if game is a timed trial with limited playtime + virtual bool BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed ) = 0; + + // set current DLC AppID being played (or 0 if none). Allows Steam to track usage of major DLC extensions + virtual bool SetDlcContext( AppId_t nAppID ) = 0; + + // returns total number of known app beta branches (including default "public" branch ) + virtual int GetNumBetas( int *pnAvailable, int *pnPrivate ) = 0; // + + // return beta branch details, name, description, current BuildID and state flags (EBetaBranchFlags) + virtual bool GetBetaInfo( int iBetaIndex, uint32 *punFlags, uint32 *punBuildID, char *pchBetaName, int cchBetaName, char *pchDescription, int cchDescription ) = 0; // iterate through + + // select this beta branch for this app as active, might need the game to restart so Steam can update to that branch + virtual bool SetActiveBeta( const char *pchBetaName ) = 0; +}; + +#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION008" + +// Global interface accessor +inline ISteamApps *SteamApps(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamApps *, SteamApps, STEAMAPPS_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif +//----------------------------------------------------------------------------- +// Purpose: posted after the user gains ownership of DLC & that DLC is installed +//----------------------------------------------------------------------------- +struct DlcInstalled_t +{ + enum { k_iCallback = k_iSteamAppsCallbacks + 5 }; + AppId_t m_nAppID; // AppID of the DLC +}; + + +//--------------------------------------------------------------------------------- +// Purpose: posted after the user gains executes a Steam URL with command line or query parameters +// such as steam://run///-commandline/?param1=value1¶m2=value2¶m3=value3 etc +// while the game is already running. The new params can be queried +// with GetLaunchQueryParam and GetLaunchCommandLine +//--------------------------------------------------------------------------------- +struct NewUrlLaunchParameters_t +{ + enum { k_iCallback = k_iSteamAppsCallbacks + 14 }; +}; + + +//----------------------------------------------------------------------------- +// Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys +// for supporting third-party CD keys, or other proof-of-purchase systems. +//----------------------------------------------------------------------------- +struct AppProofOfPurchaseKeyResponse_t +{ + enum { k_iCallback = k_iSteamAppsCallbacks + 21 }; + EResult m_eResult; + uint32 m_nAppID; + uint32 m_cchKeyLength; + char m_rgchKey[k_cubAppProofOfPurchaseKeyMax]; +}; + + +//----------------------------------------------------------------------------- +// Purpose: response to GetFileDetails +//----------------------------------------------------------------------------- +struct FileDetailsResult_t +{ + enum { k_iCallback = k_iSteamAppsCallbacks + 23 }; + EResult m_eResult; + uint64 m_ulFileSize; // original file size in bytes + uint8 m_FileSHA[20]; // original file SHA1 hash + uint32 m_unFlags; // +}; + + +//----------------------------------------------------------------------------- +// Purpose: called for games in Timed Trial mode +//----------------------------------------------------------------------------- +struct TimedTrialStatus_t +{ + enum { k_iCallback = k_iSteamAppsCallbacks + 30 }; + AppId_t m_unAppID; // appID + bool m_bIsOffline; // if true, time allowed / played refers to offline time, not total time + uint32 m_unSecondsAllowed; // how many seconds the app can be played in total + uint32 m_unSecondsPlayed; // how many seconds the app was already played +}; + +#pragma pack( pop ) +#endif // ISTEAMAPPS_H diff --git a/lsteamclient/steamworks_sdk_160/isteamappticket.h b/lsteamclient/steamworks_sdk_160/isteamappticket.h new file mode 100644 index 0000000000..77e04ece5e --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamappticket.h @@ -0,0 +1,28 @@ +//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: a private, but well versioned, interface to get at critical bits +// of a steam3 appticket - consumed by the simple drm wrapper to let it +// ask about ownership with greater confidence. +// +//============================================================================= + +#ifndef ISTEAMAPPTICKET_H +#define ISTEAMAPPTICKET_H +#include "steamtypes.h" + +//----------------------------------------------------------------------------- +// Purpose: hand out a reasonable "future proof" view of an app ownership ticket +// the raw (signed) buffer, and indices into that buffer where the appid and +// steamid are located. the sizes of the appid and steamid are implicit in +// (each version of) the interface - currently uin32 appid and uint64 steamid +//----------------------------------------------------------------------------- +class ISteamAppTicket +{ +public: + virtual uint32 GetAppOwnershipTicketData( uint32 nAppID, void *pvBuffer, uint32 cbBufferLength, uint32 *piAppId, uint32 *piSteamId, uint32 *piSignature, uint32 *pcbSignature ) = 0; +}; + +#define STEAMAPPTICKET_INTERFACE_VERSION "STEAMAPPTICKET_INTERFACE_VERSION001" + + +#endif // ISTEAMAPPTICKET_H diff --git a/lsteamclient/steamworks_sdk_160/isteamclient.h b/lsteamclient/steamworks_sdk_160/isteamclient.h new file mode 100644 index 0000000000..ce9946cbff --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamclient.h @@ -0,0 +1,173 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Internal low-level access to Steamworks interfaces. +// +// Most users of the Steamworks SDK do not need to include this file. +// You should only include this if you are doing something special. +//============================================================================= + +#ifndef ISTEAMCLIENT_H +#define ISTEAMCLIENT_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: Interface to creating a new steam instance, or to +// connect to an existing steam instance, whether it's in a +// different process or is local. +// +// For most scenarios this is all handled automatically via SteamAPI_Init(). +// You'll only need these APIs if you have a more complex versioning scheme, +// or if you want to implement a multiplexed gameserver where a single process +// is handling multiple games at once with independent gameserver SteamIDs. +//----------------------------------------------------------------------------- +class ISteamClient +{ +public: + // Creates a communication pipe to the Steam client. + // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling + virtual HSteamPipe CreateSteamPipe() = 0; + + // Releases a previously created communications pipe + // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling + virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0; + + // connects to an existing global user, failing if none exists + // used by the game to coordinate with the steamUI + // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling + virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0; + + // used by game servers, create a steam user that won't be shared with anyone else + // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling + virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0; + + // removes an allocated user + // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling + virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0; + + // retrieves the ISteamUser interface associated with the handle + virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // retrieves the ISteamGameServer interface associated with the handle + virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // set the local IP and Port to bind to + // this must be set before CreateLocalUser() + virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0; + + // returns the ISteamFriends interface + virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the ISteamUtils interface + virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the ISteamMatchmaking interface + virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the ISteamMatchmakingServers interface + virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the a generic interface + virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the ISteamUserStats interface + virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns the ISteamGameServerStats interface + virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // returns apps interface + virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // networking + virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // remote storage + virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // user screenshots + virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // game search + virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead. + STEAM_PRIVATE_API( virtual void RunFrame() = 0; ) + + // returns the number of IPC calls made since the last time this function was called + // Used for perf debugging so you can understand how many IPC calls your game makes per frame + // Every IPC call is at minimum a thread context switch if not a process one so you want to rate + // control how often you do them. + virtual uint32 GetIPCCallCount() = 0; + + // API warning handling + // 'int' is the severity; 0 for msg, 1 for warning + // 'const char *' is the text of the message + // callbacks will occur directly after the API function is called that generated the warning or message. + virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0; + + // Trigger global shutdown for the DLL + virtual bool BShutdownIfAllPipesClosed() = 0; + + // Expose HTTP interface + virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Exposes the ISteamController interface - deprecated in favor of Steam Input + virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Exposes the ISteamUGC interface + virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Music Player + virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Music Player Remote + virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; + + // html page display + virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; + + // Helper functions for internal Steam usage + STEAM_PRIVATE_API( virtual void DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; ) + STEAM_PRIVATE_API( virtual void DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; ) + STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; ) + + // inventory + virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Video + virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Parental controls + virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Exposes the Steam Input interface for controller support + virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Steam Parties interface + virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + // Steam Remote Play interface + virtual ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; + + STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; ) + +}; +#define STEAMCLIENT_INTERFACE_VERSION "SteamClient021" + +#ifndef STEAM_API_EXPORTS + +// Global ISteamClient interface accessor +inline ISteamClient *SteamClient(); +STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamClient *, SteamClient, SteamInternal_CreateInterface( STEAMCLIENT_INTERFACE_VERSION ), "global", STEAMCLIENT_INTERFACE_VERSION ); + +// The internal ISteamClient used for the gameserver interface. +// (This is actually the same thing. You really shouldn't need to access any of this stuff directly.) +inline ISteamClient *SteamGameServerClient() { return SteamClient(); } + +#endif + +#endif // ISTEAMCLIENT_H diff --git a/lsteamclient/steamworks_sdk_160/isteamcontroller.h b/lsteamclient/steamworks_sdk_160/isteamcontroller.h new file mode 100644 index 0000000000..057606c172 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamcontroller.h @@ -0,0 +1,726 @@ +//====== Copyright 1996-2018, Valve Corporation, All rights reserved. ======= +// Note: The older ISteamController interface has been deprecated in favor of ISteamInput - this interface +// was updated in this SDK but will be removed from future SDK's. The Steam Client will retain +// compatibility with the older interfaces so your any existing integrations should be unaffected. +// +// Purpose: Steam Input is a flexible input API that supports over three hundred devices including all +// common variants of Xbox, Playstation, Nintendo Switch Pro, and Steam Controllers. +// For more info including a getting started guide for developers +// please visit: https://partner.steamgames.com/doc/features/steam_controller +// +//============================================================================= + +#ifndef ISTEAMCONTROLLER_H +#define ISTEAMCONTROLLER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "isteaminput.h" + +#define STEAM_CONTROLLER_MAX_COUNT 16 + +#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 24 + +#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 256 + +#define STEAM_CONTROLLER_MAX_ORIGINS 8 + +#define STEAM_CONTROLLER_MAX_ACTIVE_LAYERS 16 + +// When sending an option to a specific controller handle, you can send to all controllers via this command +#define STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS UINT64_MAX + +#define STEAM_CONTROLLER_MIN_ANALOG_ACTION_DATA -1.0f +#define STEAM_CONTROLLER_MAX_ANALOG_ACTION_DATA 1.0f + +#ifndef ISTEAMINPUT_H +enum ESteamControllerPad +{ + k_ESteamControllerPad_Left, + k_ESteamControllerPad_Right +}; +#endif + +// Note: Please do not use action origins as a way to identify controller types. There is no +// guarantee that they will be added in a contiguous manner - use GetInputTypeForHandle instead +// Versions of Steam that add new controller types in the future will extend this enum if you're +// using a lookup table please check the bounds of any origins returned by Steam. +enum EControllerActionOrigin +{ + // Steam Controller + k_EControllerActionOrigin_None, + k_EControllerActionOrigin_A, + k_EControllerActionOrigin_B, + k_EControllerActionOrigin_X, + k_EControllerActionOrigin_Y, + k_EControllerActionOrigin_LeftBumper, + k_EControllerActionOrigin_RightBumper, + k_EControllerActionOrigin_LeftGrip, + k_EControllerActionOrigin_RightGrip, + k_EControllerActionOrigin_Start, + k_EControllerActionOrigin_Back, + k_EControllerActionOrigin_LeftPad_Touch, + k_EControllerActionOrigin_LeftPad_Swipe, + k_EControllerActionOrigin_LeftPad_Click, + k_EControllerActionOrigin_LeftPad_DPadNorth, + k_EControllerActionOrigin_LeftPad_DPadSouth, + k_EControllerActionOrigin_LeftPad_DPadWest, + k_EControllerActionOrigin_LeftPad_DPadEast, + k_EControllerActionOrigin_RightPad_Touch, + k_EControllerActionOrigin_RightPad_Swipe, + k_EControllerActionOrigin_RightPad_Click, + k_EControllerActionOrigin_RightPad_DPadNorth, + k_EControllerActionOrigin_RightPad_DPadSouth, + k_EControllerActionOrigin_RightPad_DPadWest, + k_EControllerActionOrigin_RightPad_DPadEast, + k_EControllerActionOrigin_LeftTrigger_Pull, + k_EControllerActionOrigin_LeftTrigger_Click, + k_EControllerActionOrigin_RightTrigger_Pull, + k_EControllerActionOrigin_RightTrigger_Click, + k_EControllerActionOrigin_LeftStick_Move, + k_EControllerActionOrigin_LeftStick_Click, + k_EControllerActionOrigin_LeftStick_DPadNorth, + k_EControllerActionOrigin_LeftStick_DPadSouth, + k_EControllerActionOrigin_LeftStick_DPadWest, + k_EControllerActionOrigin_LeftStick_DPadEast, + k_EControllerActionOrigin_Gyro_Move, + k_EControllerActionOrigin_Gyro_Pitch, + k_EControllerActionOrigin_Gyro_Yaw, + k_EControllerActionOrigin_Gyro_Roll, + + // PS4 Dual Shock + k_EControllerActionOrigin_PS4_X, + k_EControllerActionOrigin_PS4_Circle, + k_EControllerActionOrigin_PS4_Triangle, + k_EControllerActionOrigin_PS4_Square, + k_EControllerActionOrigin_PS4_LeftBumper, + k_EControllerActionOrigin_PS4_RightBumper, + k_EControllerActionOrigin_PS4_Options, //Start + k_EControllerActionOrigin_PS4_Share, //Back + k_EControllerActionOrigin_PS4_LeftPad_Touch, + k_EControllerActionOrigin_PS4_LeftPad_Swipe, + k_EControllerActionOrigin_PS4_LeftPad_Click, + k_EControllerActionOrigin_PS4_LeftPad_DPadNorth, + k_EControllerActionOrigin_PS4_LeftPad_DPadSouth, + k_EControllerActionOrigin_PS4_LeftPad_DPadWest, + k_EControllerActionOrigin_PS4_LeftPad_DPadEast, + k_EControllerActionOrigin_PS4_RightPad_Touch, + k_EControllerActionOrigin_PS4_RightPad_Swipe, + k_EControllerActionOrigin_PS4_RightPad_Click, + k_EControllerActionOrigin_PS4_RightPad_DPadNorth, + k_EControllerActionOrigin_PS4_RightPad_DPadSouth, + k_EControllerActionOrigin_PS4_RightPad_DPadWest, + k_EControllerActionOrigin_PS4_RightPad_DPadEast, + k_EControllerActionOrigin_PS4_CenterPad_Touch, + k_EControllerActionOrigin_PS4_CenterPad_Swipe, + k_EControllerActionOrigin_PS4_CenterPad_Click, + k_EControllerActionOrigin_PS4_CenterPad_DPadNorth, + k_EControllerActionOrigin_PS4_CenterPad_DPadSouth, + k_EControllerActionOrigin_PS4_CenterPad_DPadWest, + k_EControllerActionOrigin_PS4_CenterPad_DPadEast, + k_EControllerActionOrigin_PS4_LeftTrigger_Pull, + k_EControllerActionOrigin_PS4_LeftTrigger_Click, + k_EControllerActionOrigin_PS4_RightTrigger_Pull, + k_EControllerActionOrigin_PS4_RightTrigger_Click, + k_EControllerActionOrigin_PS4_LeftStick_Move, + k_EControllerActionOrigin_PS4_LeftStick_Click, + k_EControllerActionOrigin_PS4_LeftStick_DPadNorth, + k_EControllerActionOrigin_PS4_LeftStick_DPadSouth, + k_EControllerActionOrigin_PS4_LeftStick_DPadWest, + k_EControllerActionOrigin_PS4_LeftStick_DPadEast, + k_EControllerActionOrigin_PS4_RightStick_Move, + k_EControllerActionOrigin_PS4_RightStick_Click, + k_EControllerActionOrigin_PS4_RightStick_DPadNorth, + k_EControllerActionOrigin_PS4_RightStick_DPadSouth, + k_EControllerActionOrigin_PS4_RightStick_DPadWest, + k_EControllerActionOrigin_PS4_RightStick_DPadEast, + k_EControllerActionOrigin_PS4_DPad_North, + k_EControllerActionOrigin_PS4_DPad_South, + k_EControllerActionOrigin_PS4_DPad_West, + k_EControllerActionOrigin_PS4_DPad_East, + k_EControllerActionOrigin_PS4_Gyro_Move, + k_EControllerActionOrigin_PS4_Gyro_Pitch, + k_EControllerActionOrigin_PS4_Gyro_Yaw, + k_EControllerActionOrigin_PS4_Gyro_Roll, + + // XBox One + k_EControllerActionOrigin_XBoxOne_A, + k_EControllerActionOrigin_XBoxOne_B, + k_EControllerActionOrigin_XBoxOne_X, + k_EControllerActionOrigin_XBoxOne_Y, + k_EControllerActionOrigin_XBoxOne_LeftBumper, + k_EControllerActionOrigin_XBoxOne_RightBumper, + k_EControllerActionOrigin_XBoxOne_Menu, //Start + k_EControllerActionOrigin_XBoxOne_View, //Back + k_EControllerActionOrigin_XBoxOne_LeftTrigger_Pull, + k_EControllerActionOrigin_XBoxOne_LeftTrigger_Click, + k_EControllerActionOrigin_XBoxOne_RightTrigger_Pull, + k_EControllerActionOrigin_XBoxOne_RightTrigger_Click, + k_EControllerActionOrigin_XBoxOne_LeftStick_Move, + k_EControllerActionOrigin_XBoxOne_LeftStick_Click, + k_EControllerActionOrigin_XBoxOne_LeftStick_DPadNorth, + k_EControllerActionOrigin_XBoxOne_LeftStick_DPadSouth, + k_EControllerActionOrigin_XBoxOne_LeftStick_DPadWest, + k_EControllerActionOrigin_XBoxOne_LeftStick_DPadEast, + k_EControllerActionOrigin_XBoxOne_RightStick_Move, + k_EControllerActionOrigin_XBoxOne_RightStick_Click, + k_EControllerActionOrigin_XBoxOne_RightStick_DPadNorth, + k_EControllerActionOrigin_XBoxOne_RightStick_DPadSouth, + k_EControllerActionOrigin_XBoxOne_RightStick_DPadWest, + k_EControllerActionOrigin_XBoxOne_RightStick_DPadEast, + k_EControllerActionOrigin_XBoxOne_DPad_North, + k_EControllerActionOrigin_XBoxOne_DPad_South, + k_EControllerActionOrigin_XBoxOne_DPad_West, + k_EControllerActionOrigin_XBoxOne_DPad_East, + + // XBox 360 + k_EControllerActionOrigin_XBox360_A, + k_EControllerActionOrigin_XBox360_B, + k_EControllerActionOrigin_XBox360_X, + k_EControllerActionOrigin_XBox360_Y, + k_EControllerActionOrigin_XBox360_LeftBumper, + k_EControllerActionOrigin_XBox360_RightBumper, + k_EControllerActionOrigin_XBox360_Start, //Start + k_EControllerActionOrigin_XBox360_Back, //Back + k_EControllerActionOrigin_XBox360_LeftTrigger_Pull, + k_EControllerActionOrigin_XBox360_LeftTrigger_Click, + k_EControllerActionOrigin_XBox360_RightTrigger_Pull, + k_EControllerActionOrigin_XBox360_RightTrigger_Click, + k_EControllerActionOrigin_XBox360_LeftStick_Move, + k_EControllerActionOrigin_XBox360_LeftStick_Click, + k_EControllerActionOrigin_XBox360_LeftStick_DPadNorth, + k_EControllerActionOrigin_XBox360_LeftStick_DPadSouth, + k_EControllerActionOrigin_XBox360_LeftStick_DPadWest, + k_EControllerActionOrigin_XBox360_LeftStick_DPadEast, + k_EControllerActionOrigin_XBox360_RightStick_Move, + k_EControllerActionOrigin_XBox360_RightStick_Click, + k_EControllerActionOrigin_XBox360_RightStick_DPadNorth, + k_EControllerActionOrigin_XBox360_RightStick_DPadSouth, + k_EControllerActionOrigin_XBox360_RightStick_DPadWest, + k_EControllerActionOrigin_XBox360_RightStick_DPadEast, + k_EControllerActionOrigin_XBox360_DPad_North, + k_EControllerActionOrigin_XBox360_DPad_South, + k_EControllerActionOrigin_XBox360_DPad_West, + k_EControllerActionOrigin_XBox360_DPad_East, + + // SteamController V2 + k_EControllerActionOrigin_SteamV2_A, + k_EControllerActionOrigin_SteamV2_B, + k_EControllerActionOrigin_SteamV2_X, + k_EControllerActionOrigin_SteamV2_Y, + k_EControllerActionOrigin_SteamV2_LeftBumper, + k_EControllerActionOrigin_SteamV2_RightBumper, + k_EControllerActionOrigin_SteamV2_LeftGrip_Lower, + k_EControllerActionOrigin_SteamV2_LeftGrip_Upper, + k_EControllerActionOrigin_SteamV2_RightGrip_Lower, + k_EControllerActionOrigin_SteamV2_RightGrip_Upper, + k_EControllerActionOrigin_SteamV2_LeftBumper_Pressure, + k_EControllerActionOrigin_SteamV2_RightBumper_Pressure, + k_EControllerActionOrigin_SteamV2_LeftGrip_Pressure, + k_EControllerActionOrigin_SteamV2_RightGrip_Pressure, + k_EControllerActionOrigin_SteamV2_LeftGrip_Upper_Pressure, + k_EControllerActionOrigin_SteamV2_RightGrip_Upper_Pressure, + k_EControllerActionOrigin_SteamV2_Start, + k_EControllerActionOrigin_SteamV2_Back, + k_EControllerActionOrigin_SteamV2_LeftPad_Touch, + k_EControllerActionOrigin_SteamV2_LeftPad_Swipe, + k_EControllerActionOrigin_SteamV2_LeftPad_Click, + k_EControllerActionOrigin_SteamV2_LeftPad_Pressure, + k_EControllerActionOrigin_SteamV2_LeftPad_DPadNorth, + k_EControllerActionOrigin_SteamV2_LeftPad_DPadSouth, + k_EControllerActionOrigin_SteamV2_LeftPad_DPadWest, + k_EControllerActionOrigin_SteamV2_LeftPad_DPadEast, + k_EControllerActionOrigin_SteamV2_RightPad_Touch, + k_EControllerActionOrigin_SteamV2_RightPad_Swipe, + k_EControllerActionOrigin_SteamV2_RightPad_Click, + k_EControllerActionOrigin_SteamV2_RightPad_Pressure, + k_EControllerActionOrigin_SteamV2_RightPad_DPadNorth, + k_EControllerActionOrigin_SteamV2_RightPad_DPadSouth, + k_EControllerActionOrigin_SteamV2_RightPad_DPadWest, + k_EControllerActionOrigin_SteamV2_RightPad_DPadEast, + k_EControllerActionOrigin_SteamV2_LeftTrigger_Pull, + k_EControllerActionOrigin_SteamV2_LeftTrigger_Click, + k_EControllerActionOrigin_SteamV2_RightTrigger_Pull, + k_EControllerActionOrigin_SteamV2_RightTrigger_Click, + k_EControllerActionOrigin_SteamV2_LeftStick_Move, + k_EControllerActionOrigin_SteamV2_LeftStick_Click, + k_EControllerActionOrigin_SteamV2_LeftStick_DPadNorth, + k_EControllerActionOrigin_SteamV2_LeftStick_DPadSouth, + k_EControllerActionOrigin_SteamV2_LeftStick_DPadWest, + k_EControllerActionOrigin_SteamV2_LeftStick_DPadEast, + k_EControllerActionOrigin_SteamV2_Gyro_Move, + k_EControllerActionOrigin_SteamV2_Gyro_Pitch, + k_EControllerActionOrigin_SteamV2_Gyro_Yaw, + k_EControllerActionOrigin_SteamV2_Gyro_Roll, + + // Switch - Pro or Joycons used as a single input device. + // This does not apply to a single joycon + k_EControllerActionOrigin_Switch_A, + k_EControllerActionOrigin_Switch_B, + k_EControllerActionOrigin_Switch_X, + k_EControllerActionOrigin_Switch_Y, + k_EControllerActionOrigin_Switch_LeftBumper, + k_EControllerActionOrigin_Switch_RightBumper, + k_EControllerActionOrigin_Switch_Plus, //Start + k_EControllerActionOrigin_Switch_Minus, //Back + k_EControllerActionOrigin_Switch_Capture, + k_EControllerActionOrigin_Switch_LeftTrigger_Pull, + k_EControllerActionOrigin_Switch_LeftTrigger_Click, + k_EControllerActionOrigin_Switch_RightTrigger_Pull, + k_EControllerActionOrigin_Switch_RightTrigger_Click, + k_EControllerActionOrigin_Switch_LeftStick_Move, + k_EControllerActionOrigin_Switch_LeftStick_Click, + k_EControllerActionOrigin_Switch_LeftStick_DPadNorth, + k_EControllerActionOrigin_Switch_LeftStick_DPadSouth, + k_EControllerActionOrigin_Switch_LeftStick_DPadWest, + k_EControllerActionOrigin_Switch_LeftStick_DPadEast, + k_EControllerActionOrigin_Switch_RightStick_Move, + k_EControllerActionOrigin_Switch_RightStick_Click, + k_EControllerActionOrigin_Switch_RightStick_DPadNorth, + k_EControllerActionOrigin_Switch_RightStick_DPadSouth, + k_EControllerActionOrigin_Switch_RightStick_DPadWest, + k_EControllerActionOrigin_Switch_RightStick_DPadEast, + k_EControllerActionOrigin_Switch_DPad_North, + k_EControllerActionOrigin_Switch_DPad_South, + k_EControllerActionOrigin_Switch_DPad_West, + k_EControllerActionOrigin_Switch_DPad_East, + k_EControllerActionOrigin_Switch_ProGyro_Move, // Primary Gyro in Pro Controller, or Right JoyCon + k_EControllerActionOrigin_Switch_ProGyro_Pitch, // Primary Gyro in Pro Controller, or Right JoyCon + k_EControllerActionOrigin_Switch_ProGyro_Yaw, // Primary Gyro in Pro Controller, or Right JoyCon + k_EControllerActionOrigin_Switch_ProGyro_Roll, // Primary Gyro in Pro Controller, or Right JoyCon + // Switch JoyCon Specific + k_EControllerActionOrigin_Switch_RightGyro_Move, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EControllerActionOrigin_Switch_RightGyro_Pitch, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EControllerActionOrigin_Switch_RightGyro_Yaw, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EControllerActionOrigin_Switch_RightGyro_Roll, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EControllerActionOrigin_Switch_LeftGyro_Move, + k_EControllerActionOrigin_Switch_LeftGyro_Pitch, + k_EControllerActionOrigin_Switch_LeftGyro_Yaw, + k_EControllerActionOrigin_Switch_LeftGyro_Roll, + k_EControllerActionOrigin_Switch_LeftGrip_Lower, // Left JoyCon SR Button + k_EControllerActionOrigin_Switch_LeftGrip_Upper, // Left JoyCon SL Button + k_EControllerActionOrigin_Switch_RightGrip_Lower, // Right JoyCon SL Button + k_EControllerActionOrigin_Switch_RightGrip_Upper, // Right JoyCon SR Button + + // Added in SDK 1.45 + k_EControllerActionOrigin_PS4_DPad_Move, + k_EControllerActionOrigin_XBoxOne_DPad_Move, + k_EControllerActionOrigin_XBox360_DPad_Move, + k_EControllerActionOrigin_Switch_DPad_Move, + + // Added in SDK 1.51 + k_EControllerActionOrigin_PS5_X, + k_EControllerActionOrigin_PS5_Circle, + k_EControllerActionOrigin_PS5_Triangle, + k_EControllerActionOrigin_PS5_Square, + k_EControllerActionOrigin_PS5_LeftBumper, + k_EControllerActionOrigin_PS5_RightBumper, + k_EControllerActionOrigin_PS5_Option, //Start + k_EControllerActionOrigin_PS5_Create, //Back + k_EControllerActionOrigin_PS5_Mute, + k_EControllerActionOrigin_PS5_LeftPad_Touch, + k_EControllerActionOrigin_PS5_LeftPad_Swipe, + k_EControllerActionOrigin_PS5_LeftPad_Click, + k_EControllerActionOrigin_PS5_LeftPad_DPadNorth, + k_EControllerActionOrigin_PS5_LeftPad_DPadSouth, + k_EControllerActionOrigin_PS5_LeftPad_DPadWest, + k_EControllerActionOrigin_PS5_LeftPad_DPadEast, + k_EControllerActionOrigin_PS5_RightPad_Touch, + k_EControllerActionOrigin_PS5_RightPad_Swipe, + k_EControllerActionOrigin_PS5_RightPad_Click, + k_EControllerActionOrigin_PS5_RightPad_DPadNorth, + k_EControllerActionOrigin_PS5_RightPad_DPadSouth, + k_EControllerActionOrigin_PS5_RightPad_DPadWest, + k_EControllerActionOrigin_PS5_RightPad_DPadEast, + k_EControllerActionOrigin_PS5_CenterPad_Touch, + k_EControllerActionOrigin_PS5_CenterPad_Swipe, + k_EControllerActionOrigin_PS5_CenterPad_Click, + k_EControllerActionOrigin_PS5_CenterPad_DPadNorth, + k_EControllerActionOrigin_PS5_CenterPad_DPadSouth, + k_EControllerActionOrigin_PS5_CenterPad_DPadWest, + k_EControllerActionOrigin_PS5_CenterPad_DPadEast, + k_EControllerActionOrigin_PS5_LeftTrigger_Pull, + k_EControllerActionOrigin_PS5_LeftTrigger_Click, + k_EControllerActionOrigin_PS5_RightTrigger_Pull, + k_EControllerActionOrigin_PS5_RightTrigger_Click, + k_EControllerActionOrigin_PS5_LeftStick_Move, + k_EControllerActionOrigin_PS5_LeftStick_Click, + k_EControllerActionOrigin_PS5_LeftStick_DPadNorth, + k_EControllerActionOrigin_PS5_LeftStick_DPadSouth, + k_EControllerActionOrigin_PS5_LeftStick_DPadWest, + k_EControllerActionOrigin_PS5_LeftStick_DPadEast, + k_EControllerActionOrigin_PS5_RightStick_Move, + k_EControllerActionOrigin_PS5_RightStick_Click, + k_EControllerActionOrigin_PS5_RightStick_DPadNorth, + k_EControllerActionOrigin_PS5_RightStick_DPadSouth, + k_EControllerActionOrigin_PS5_RightStick_DPadWest, + k_EControllerActionOrigin_PS5_RightStick_DPadEast, + k_EControllerActionOrigin_PS5_DPad_Move, + k_EControllerActionOrigin_PS5_DPad_North, + k_EControllerActionOrigin_PS5_DPad_South, + k_EControllerActionOrigin_PS5_DPad_West, + k_EControllerActionOrigin_PS5_DPad_East, + k_EControllerActionOrigin_PS5_Gyro_Move, + k_EControllerActionOrigin_PS5_Gyro_Pitch, + k_EControllerActionOrigin_PS5_Gyro_Yaw, + k_EControllerActionOrigin_PS5_Gyro_Roll, + + k_EControllerActionOrigin_XBoxOne_LeftGrip_Lower, + k_EControllerActionOrigin_XBoxOne_LeftGrip_Upper, + k_EControllerActionOrigin_XBoxOne_RightGrip_Lower, + k_EControllerActionOrigin_XBoxOne_RightGrip_Upper, + k_EControllerActionOrigin_XBoxOne_Share, + + // Added in SDK 1.53 + k_EControllerActionOrigin_SteamDeck_A, + k_EControllerActionOrigin_SteamDeck_B, + k_EControllerActionOrigin_SteamDeck_X, + k_EControllerActionOrigin_SteamDeck_Y, + k_EControllerActionOrigin_SteamDeck_L1, + k_EControllerActionOrigin_SteamDeck_R1, + k_EControllerActionOrigin_SteamDeck_Menu, + k_EControllerActionOrigin_SteamDeck_View, + k_EControllerActionOrigin_SteamDeck_LeftPad_Touch, + k_EControllerActionOrigin_SteamDeck_LeftPad_Swipe, + k_EControllerActionOrigin_SteamDeck_LeftPad_Click, + k_EControllerActionOrigin_SteamDeck_LeftPad_DPadNorth, + k_EControllerActionOrigin_SteamDeck_LeftPad_DPadSouth, + k_EControllerActionOrigin_SteamDeck_LeftPad_DPadWest, + k_EControllerActionOrigin_SteamDeck_LeftPad_DPadEast, + k_EControllerActionOrigin_SteamDeck_RightPad_Touch, + k_EControllerActionOrigin_SteamDeck_RightPad_Swipe, + k_EControllerActionOrigin_SteamDeck_RightPad_Click, + k_EControllerActionOrigin_SteamDeck_RightPad_DPadNorth, + k_EControllerActionOrigin_SteamDeck_RightPad_DPadSouth, + k_EControllerActionOrigin_SteamDeck_RightPad_DPadWest, + k_EControllerActionOrigin_SteamDeck_RightPad_DPadEast, + k_EControllerActionOrigin_SteamDeck_L2_SoftPull, + k_EControllerActionOrigin_SteamDeck_L2, + k_EControllerActionOrigin_SteamDeck_R2_SoftPull, + k_EControllerActionOrigin_SteamDeck_R2, + k_EControllerActionOrigin_SteamDeck_LeftStick_Move, + k_EControllerActionOrigin_SteamDeck_L3, + k_EControllerActionOrigin_SteamDeck_LeftStick_DPadNorth, + k_EControllerActionOrigin_SteamDeck_LeftStick_DPadSouth, + k_EControllerActionOrigin_SteamDeck_LeftStick_DPadWest, + k_EControllerActionOrigin_SteamDeck_LeftStick_DPadEast, + k_EControllerActionOrigin_SteamDeck_LeftStick_Touch, + k_EControllerActionOrigin_SteamDeck_RightStick_Move, + k_EControllerActionOrigin_SteamDeck_R3, + k_EControllerActionOrigin_SteamDeck_RightStick_DPadNorth, + k_EControllerActionOrigin_SteamDeck_RightStick_DPadSouth, + k_EControllerActionOrigin_SteamDeck_RightStick_DPadWest, + k_EControllerActionOrigin_SteamDeck_RightStick_DPadEast, + k_EControllerActionOrigin_SteamDeck_RightStick_Touch, + k_EControllerActionOrigin_SteamDeck_L4, + k_EControllerActionOrigin_SteamDeck_R4, + k_EControllerActionOrigin_SteamDeck_L5, + k_EControllerActionOrigin_SteamDeck_R5, + k_EControllerActionOrigin_SteamDeck_DPad_Move, + k_EControllerActionOrigin_SteamDeck_DPad_North, + k_EControllerActionOrigin_SteamDeck_DPad_South, + k_EControllerActionOrigin_SteamDeck_DPad_West, + k_EControllerActionOrigin_SteamDeck_DPad_East, + k_EControllerActionOrigin_SteamDeck_Gyro_Move, + k_EControllerActionOrigin_SteamDeck_Gyro_Pitch, + k_EControllerActionOrigin_SteamDeck_Gyro_Yaw, + k_EControllerActionOrigin_SteamDeck_Gyro_Roll, + k_EControllerActionOrigin_SteamDeck_Reserved1, + k_EControllerActionOrigin_SteamDeck_Reserved2, + k_EControllerActionOrigin_SteamDeck_Reserved3, + k_EControllerActionOrigin_SteamDeck_Reserved4, + k_EControllerActionOrigin_SteamDeck_Reserved5, + k_EControllerActionOrigin_SteamDeck_Reserved6, + k_EControllerActionOrigin_SteamDeck_Reserved7, + k_EControllerActionOrigin_SteamDeck_Reserved8, + k_EControllerActionOrigin_SteamDeck_Reserved9, + k_EControllerActionOrigin_SteamDeck_Reserved10, + k_EControllerActionOrigin_SteamDeck_Reserved11, + k_EControllerActionOrigin_SteamDeck_Reserved12, + k_EControllerActionOrigin_SteamDeck_Reserved13, + k_EControllerActionOrigin_SteamDeck_Reserved14, + k_EControllerActionOrigin_SteamDeck_Reserved15, + k_EControllerActionOrigin_SteamDeck_Reserved16, + k_EControllerActionOrigin_SteamDeck_Reserved17, + k_EControllerActionOrigin_SteamDeck_Reserved18, + k_EControllerActionOrigin_SteamDeck_Reserved19, + k_EControllerActionOrigin_SteamDeck_Reserved20, + + k_EControllerActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical + k_EControllerActionOrigin_Switch_JoyConButton_E, // X + k_EControllerActionOrigin_Switch_JoyConButton_S, // A + k_EControllerActionOrigin_Switch_JoyConButton_W, // B + + k_EControllerActionOrigin_PS5_LeftGrip, + k_EControllerActionOrigin_PS5_RightGrip, + k_EControllerActionOrigin_PS5_LeftFn, + k_EControllerActionOrigin_PS5_RightFn, + + k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here. + k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits. +}; + +#ifndef ISTEAMINPUT_H +enum EXboxOrigin +{ + k_EXboxOrigin_A, + k_EXboxOrigin_B, + k_EXboxOrigin_X, + k_EXboxOrigin_Y, + k_EXboxOrigin_LeftBumper, + k_EXboxOrigin_RightBumper, + k_EXboxOrigin_Menu, //Start + k_EXboxOrigin_View, //Back + k_EXboxOrigin_LeftTrigger_Pull, + k_EXboxOrigin_LeftTrigger_Click, + k_EXboxOrigin_RightTrigger_Pull, + k_EXboxOrigin_RightTrigger_Click, + k_EXboxOrigin_LeftStick_Move, + k_EXboxOrigin_LeftStick_Click, + k_EXboxOrigin_LeftStick_DPadNorth, + k_EXboxOrigin_LeftStick_DPadSouth, + k_EXboxOrigin_LeftStick_DPadWest, + k_EXboxOrigin_LeftStick_DPadEast, + k_EXboxOrigin_RightStick_Move, + k_EXboxOrigin_RightStick_Click, + k_EXboxOrigin_RightStick_DPadNorth, + k_EXboxOrigin_RightStick_DPadSouth, + k_EXboxOrigin_RightStick_DPadWest, + k_EXboxOrigin_RightStick_DPadEast, + k_EXboxOrigin_DPad_North, + k_EXboxOrigin_DPad_South, + k_EXboxOrigin_DPad_West, + k_EXboxOrigin_DPad_East, +}; + +enum ESteamInputType +{ + k_ESteamInputType_Unknown, + k_ESteamInputType_SteamController, + k_ESteamInputType_XBox360Controller, + k_ESteamInputType_XBoxOneController, + k_ESteamInputType_GenericGamepad, // DirectInput controllers + k_ESteamInputType_PS4Controller, + k_ESteamInputType_AppleMFiController, // Unused + k_ESteamInputType_AndroidController, // Unused + k_ESteamInputType_SwitchJoyConPair, // Unused + k_ESteamInputType_SwitchJoyConSingle, // Unused + k_ESteamInputType_SwitchProController, + k_ESteamInputType_MobileTouch, // Steam Link App On-screen Virtual Controller + k_ESteamInputType_PS3Controller, // Currently uses PS4 Origins + k_ESteamInputType_PS5Controller, // Added in SDK 151 + k_ESteamInputType_Count, + k_ESteamInputType_MaximumPossibleValue = 255, +}; +#endif + +enum ESteamControllerLEDFlag +{ + k_ESteamControllerLEDFlag_SetColor, + k_ESteamControllerLEDFlag_RestoreUserDefault +}; + +// ControllerHandle_t is used to refer to a specific controller. +// This handle will consistently identify a controller, even if it is disconnected and re-connected +typedef uint64 ControllerHandle_t; + + +// These handles are used to refer to a specific in-game action or action set +// All action handles should be queried during initialization for performance reasons +typedef uint64 ControllerActionSetHandle_t; +typedef uint64 ControllerDigitalActionHandle_t; +typedef uint64 ControllerAnalogActionHandle_t; + +#pragma pack( push, 1 ) + +#ifdef ISTEAMINPUT_H +#define ControllerAnalogActionData_t InputAnalogActionData_t +#define ControllerDigitalActionData_t InputDigitalActionData_t +#define ControllerMotionData_t InputMotionData_t +#else +struct ControllerAnalogActionData_t +{ + // Type of data coming from this action, this will match what got specified in the action set + EControllerSourceMode eMode; + + // The current state of this action; will be delta updates for mouse actions + float x, y; + + // Whether or not this action is currently available to be bound in the active action set + bool bActive; +}; + +struct ControllerDigitalActionData_t +{ + // The current state of this action; will be true if currently pressed + bool bState; + + // Whether or not this action is currently available to be bound in the active action set + bool bActive; +}; + +struct ControllerMotionData_t +{ + // Sensor-fused absolute rotation; will drift in heading + float rotQuatX; + float rotQuatY; + float rotQuatZ; + float rotQuatW; + + // Positional acceleration + float posAccelX; + float posAccelY; + float posAccelZ; + + // Angular velocity + float rotVelX; + float rotVelY; + float rotVelZ; +}; +#endif +#pragma pack( pop ) + + +//----------------------------------------------------------------------------- +// Purpose: Steam Input API +//----------------------------------------------------------------------------- +class ISteamController +{ +public: + + // Init and Shutdown must be called when starting/ending use of this interface + virtual bool Init() = 0; + virtual bool Shutdown() = 0; + + // Synchronize API state with the latest Steam Controller inputs available. This + // is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest + // possible latency, you call this directly before reading controller state. This must + // be called from somewhere before GetConnectedControllers will return any handles + virtual void RunFrame() = 0; + + // Enumerate currently connected controllers + // handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles + // Returns the number of handles written to handlesOut + virtual int GetConnectedControllers( STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_COUNT, Receives list of connected controllers ) ControllerHandle_t *handlesOut ) = 0; + + //----------------------------------------------------------------------------- + // ACTION SETS + //----------------------------------------------------------------------------- + + // Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls. + virtual ControllerActionSetHandle_t GetActionSetHandle( const char *pszActionSetName ) = 0; + + // Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive') + // This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in + // your state loops, instead of trying to place it in all of your state transitions. + virtual void ActivateActionSet( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ) = 0; + virtual ControllerActionSetHandle_t GetCurrentActionSet( ControllerHandle_t controllerHandle ) = 0; + + // ACTION SET LAYERS + virtual void ActivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) = 0; + virtual void DeactivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) = 0; + virtual void DeactivateAllActionSetLayers( ControllerHandle_t controllerHandle ) = 0; + // Enumerate currently active layers + // handlesOut should point to a STEAM_CONTROLLER_MAX_ACTIVE_LAYERS sized array of ControllerActionSetHandle_t handles. + // Returns the number of handles written to handlesOut + virtual int GetActiveActionSetLayers( ControllerHandle_t controllerHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ACTIVE_LAYERS, Receives list of active layers ) ControllerActionSetHandle_t *handlesOut ) = 0; + + //----------------------------------------------------------------------------- + // ACTIONS + //----------------------------------------------------------------------------- + + // Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls. + virtual ControllerDigitalActionHandle_t GetDigitalActionHandle( const char *pszActionName ) = 0; + + // Returns the current state of the supplied digital game action + virtual ControllerDigitalActionData_t GetDigitalActionData( ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ) = 0; + + // Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. + // originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles. The EControllerActionOrigin enum will get extended as support for new controller controllers gets added to + // the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. + virtual int GetDigitalActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ORIGINS, Receives list of aciton origins ) EControllerActionOrigin *originsOut ) = 0; + + // Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls. + virtual ControllerAnalogActionHandle_t GetAnalogActionHandle( const char *pszActionName ) = 0; + + // Returns the current state of these supplied analog game action + virtual ControllerAnalogActionData_t GetAnalogActionData( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ) = 0; + + // Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. + // originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles. The EControllerActionOrigin enum will get extended as support for new controller controllers gets added to + // the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. + virtual int GetAnalogActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ORIGINS, Receives list of action origins ) EControllerActionOrigin *originsOut ) = 0; + + // Get a local path to art for on-screen glyph for a particular origin - this call is cheap + virtual const char *GetGlyphForActionOrigin( EControllerActionOrigin eOrigin ) = 0; + + // Returns a localized string (from Steam's language setting) for the specified origin - this call is serialized + virtual const char *GetStringForActionOrigin( EControllerActionOrigin eOrigin ) = 0; + + virtual void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ) = 0; + + // Returns raw motion data from the specified controller + virtual ControllerMotionData_t GetMotionData( ControllerHandle_t controllerHandle ) = 0; + + //----------------------------------------------------------------------------- + // OUTPUTS + //----------------------------------------------------------------------------- + + // Trigger a haptic pulse on a controller + virtual void TriggerHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0; + + // Trigger a pulse with a duty cycle of usDurationMicroSec / usOffMicroSec, unRepeat times. + // nFlags is currently unused and reserved for future use. + virtual void TriggerRepeatedHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ) = 0; + + // Trigger a vibration event on supported controllers. + virtual void TriggerVibration( ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ) = 0; + + // Set the controller LED color on supported controllers. + virtual void SetLEDColor( ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ) = 0; + + //----------------------------------------------------------------------------- + // Utility functions available without using the rest of Steam Input API + //----------------------------------------------------------------------------- + + // Invokes the Steam overlay and brings up the binding screen if the user is using Big Picture Mode + // If the user is not in Big Picture Mode it will open up the binding in a new window + virtual bool ShowBindingPanel( ControllerHandle_t controllerHandle ) = 0; + + // Returns the input type for a particular handle - unlike EControllerActionOrigin which update with Steam and may return unrecognized values + // ESteamInputType will remain static and only return valid values from your SDK version + virtual ESteamInputType GetInputTypeForHandle( ControllerHandle_t controllerHandle ) = 0; + + // Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions + // to identify controllers presented to your game over Xinput. Returns 0 if the Xinput index isn't associated with Steam Input + virtual ControllerHandle_t GetControllerForGamepadIndex( int nIndex ) = 0; + + // Returns the associated gamepad index for the specified controller, if emulating a gamepad or -1 if not associated with an Xinput index + virtual int GetGamepadIndexForController( ControllerHandle_t ulControllerHandle ) = 0; + + // Returns a localized string (from Steam's language setting) for the specified Xbox controller origin. + virtual const char *GetStringForXboxOrigin( EXboxOrigin eOrigin ) = 0; + + // Get a local path to art for on-screen glyph for a particular Xbox controller origin. + virtual const char *GetGlyphForXboxOrigin( EXboxOrigin eOrigin ) = 0; + + // Get the equivalent ActionOrigin for a given Xbox controller origin this can be chained with GetGlyphForActionOrigin to provide future proof glyphs for + // non-Steam Input API action games. Note - this only translates the buttons directly and doesn't take into account any remapping a user has made in their configuration + virtual EControllerActionOrigin GetActionOriginFromXboxOrigin( ControllerHandle_t controllerHandle, EXboxOrigin eOrigin ) = 0; + + // Convert an origin to another controller type - for inputs not present on the other controller type this will return k_EControllerActionOrigin_None + virtual EControllerActionOrigin TranslateActionOrigin( ESteamInputType eDestinationInputType, EControllerActionOrigin eSourceOrigin ) = 0; + + // Get the binding revision for a given device. Returns false if the handle was not valid or if a mapping is not yet loaded for the device + virtual bool GetControllerBindingRevision( ControllerHandle_t controllerHandle, int *pMajor, int *pMinor ) = 0; +}; + +#define STEAMCONTROLLER_INTERFACE_VERSION "SteamController008" + +// Global interface accessor +inline ISteamController *SteamController(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamController *, SteamController, STEAMCONTROLLER_INTERFACE_VERSION ); + +#endif // ISTEAMCONTROLLER_H diff --git a/lsteamclient/steamworks_sdk_160/isteamdualsense.h b/lsteamclient/steamworks_sdk_160/isteamdualsense.h new file mode 100644 index 0000000000..5acc85743c --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamdualsense.h @@ -0,0 +1,169 @@ +/* SIE CONFIDENTIAL + * $PSLibId$ + * Copyright (C) 2019 Sony Interactive Entertainment Inc. + * All Rights Reserved. + */ + + +#ifndef _SCE_PAD_TRIGGER_EFFECT_H +#define _SCE_PAD_TRIGGER_EFFECT_H + + +#define SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_L2 0x01 +#define SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_R2 0x02 + +#define SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_L2 0 +#define SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 1 + +#define SCE_PAD_TRIGGER_EFFECT_TRIGGER_NUM 2 + +/* Definition of control point num */ +#define SCE_PAD_TRIGGER_EFFECT_CONTROL_POINT_NUM 10 + +typedef enum ScePadTriggerEffectMode{ + SCE_PAD_TRIGGER_EFFECT_MODE_OFF, + SCE_PAD_TRIGGER_EFFECT_MODE_FEEDBACK, + SCE_PAD_TRIGGER_EFFECT_MODE_WEAPON, + SCE_PAD_TRIGGER_EFFECT_MODE_VIBRATION, + SCE_PAD_TRIGGER_EFFECT_MODE_MULTIPLE_POSITION_FEEDBACK, + SCE_PAD_TRIGGER_EFFECT_MODE_SLOPE_FEEDBACK, + SCE_PAD_TRIGGER_EFFECT_MODE_MULTIPLE_POSITION_VIBRATION, +} ScePadTriggerEffectMode; + +/** + *E + * @brief parameter for setting the trigger effect to off mode. + * Off Mode: Stop trigger effect. + **/ +typedef struct ScePadTriggerEffectOffParam{ + uint8_t padding[48]; +} ScePadTriggerEffectOffParam; + +/** + *E + * @brief parameter for setting the trigger effect to Feedback mode. + * Feedback Mode: The motor arm pushes back trigger. + * Trigger obtains stiffness at specified position. + **/ +typedef struct ScePadTriggerEffectFeedbackParam{ + uint8_t position; /*E position where the strength of target trigger start changing(0~9). */ + uint8_t strength; /*E strength that the motor arm pushes back target trigger(0~8 (0: Same as Off mode)). */ + uint8_t padding[46]; +} ScePadTriggerEffectFeedbackParam; + +/** + *E + * @brief parameter for setting the trigger effect to Weapon mode. + * Weapon Mode: Emulate weapon like gun trigger. + **/ +typedef struct ScePadTriggerEffectWeaponParam{ + uint8_t startPosition; /*E position where the stiffness of trigger start changing(2~7). */ + uint8_t endPosition; /*E position where the stiffness of trigger finish changing(startPosition+1~8). */ + uint8_t strength; /*E strength of gun trigger(0~8 (0: Same as Off mode)). */ + uint8_t padding[45]; +} ScePadTriggerEffectWeaponParam; + +/** + *E + * @brief parameter for setting the trigger effect to Vibration mode. + * Vibration Mode: Vibrates motor arm around specified position. + **/ +typedef struct ScePadTriggerEffectVibrationParam{ + uint8_t position; /*E position where the motor arm start vibrating(0~9). */ + uint8_t amplitude; /*E vibration amplitude(0~8 (0: Same as Off mode)). */ + uint8_t frequency; /*E vibration frequency(0~255[Hz] (0: Same as Off mode)). */ + uint8_t padding[45]; +} ScePadTriggerEffectVibrationParam; + +/** + *E + * @brief parameter for setting the trigger effect to ScePadTriggerEffectMultiplePositionFeedbackParam mode. + * Multi Position Feedback Mode: The motor arm pushes back trigger. + * Trigger obtains specified stiffness at each control point. + **/ +typedef struct ScePadTriggerEffectMultiplePositionFeedbackParam{ + uint8_t strength[SCE_PAD_TRIGGER_EFFECT_CONTROL_POINT_NUM]; /*E strength that the motor arm pushes back target trigger at position(0~8 (0: Same as Off mode)). + * strength[0] means strength of motor arm at position0. + * strength[1] means strength of motor arm at position1. + * ... + * */ + uint8_t padding[38]; +} ScePadTriggerEffectMultiplePositionFeedbackParam; + +/** + *E + * @brief parameter for setting the trigger effect to Feedback3 mode. + * Slope Feedback Mode: The motor arm pushes back trigger between two spedified control points. + * Stiffness of the trigger is changing depending on the set place. + **/ +typedef struct ScePadTriggerEffectSlopeFeedbackParam{ + + uint8_t startPosition; /*E position where the strength of target trigger start changing(0~endPosition). */ + uint8_t endPosition; /*E position where the strength of target trigger finish changing(startPosition+1~9). */ + uint8_t startStrength; /*E strength when trigger's position is startPosition(1~8) */ + uint8_t endStrength; /*E strength when trigger's position is endPosition(1~8) */ + uint8_t padding[44]; +} ScePadTriggerEffectSlopeFeedbackParam; + +/** + *E + * @brief parameter for setting the trigger effect to Vibration2 mode. + * Multi Position Vibration Mode: Vibrates motor arm around specified control point. + * Trigger vibrates specified amplitude at each control point. + **/ +typedef struct ScePadTriggerEffectMultiplePositionVibrationParam{ + uint8_t frequency; /*E vibration frequency(0~255 (0: Same as Off mode)) */ + uint8_t amplitude[SCE_PAD_TRIGGER_EFFECT_CONTROL_POINT_NUM]; /*E vibration amplitude at position(0~8 (0: Same as Off mode)). + * amplitude[0] means amplitude of vibration at position0. + * amplitude[1] means amplitude of vibration at position1. + * ... + * */ + uint8_t padding[37]; +} ScePadTriggerEffectMultiplePositionVibrationParam; + +/** + *E + * @brief parameter for setting the trigger effect mode. + **/ +typedef union ScePadTriggerEffectCommandData{ + ScePadTriggerEffectOffParam offParam; + ScePadTriggerEffectFeedbackParam feedbackParam; + ScePadTriggerEffectWeaponParam weaponParam; + ScePadTriggerEffectVibrationParam vibrationParam; + ScePadTriggerEffectMultiplePositionFeedbackParam multiplePositionFeedbackParam; + ScePadTriggerEffectSlopeFeedbackParam slopeFeedbackParam; + ScePadTriggerEffectMultiplePositionVibrationParam multiplePositionVibrationParam; +} ScePadTriggerEffectCommandData; + +/** + *E + * @brief parameter for setting the trigger effect. + **/ +typedef struct ScePadTriggerEffectCommand{ + ScePadTriggerEffectMode mode; + uint8_t padding[4]; + ScePadTriggerEffectCommandData commandData; +} ScePadTriggerEffectCommand; + +/** + *E + * @brief parameter for the scePadSetTriggerEffect function. + **/ +typedef struct ScePadTriggerEffectParam{ + + uint8_t triggerMask; /*E Set trigger mask to activate trigger effect commands. + * SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_L2 : 0x01 + * SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_R2 : 0x02 + * */ + uint8_t padding[7]; + + ScePadTriggerEffectCommand command[SCE_PAD_TRIGGER_EFFECT_TRIGGER_NUM]; /*E command[SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_L2] is for L2 trigger setting + * and param[SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2] is for R2 trgger setting. + * */ +} ScePadTriggerEffectParam; + +#if defined(__cplusplus) && __cplusplus >= 201103L +static_assert( sizeof( ScePadTriggerEffectParam ) == 120, "ScePadTriggerEffectParam has incorrect size" ); +#endif + +#endif /* _SCE_PAD_TRIGGER_EFFECT_H */ diff --git a/lsteamclient/steamworks_sdk_160/isteamfriends.h b/lsteamclient/steamworks_sdk_160/isteamfriends.h new file mode 100644 index 0000000000..26351eee37 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamfriends.h @@ -0,0 +1,757 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Purpose: interface to both friends list data and general information about users +// +//============================================================================= + +#ifndef ISTEAMFRIENDS_H +#define ISTEAMFRIENDS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: set of relationships to other users +//----------------------------------------------------------------------------- +enum EFriendRelationship +{ + k_EFriendRelationshipNone = 0, + k_EFriendRelationshipBlocked = 1, // this doesn't get stored; the user has just done an Ignore on an friendship invite + k_EFriendRelationshipRequestRecipient = 2, + k_EFriendRelationshipFriend = 3, + k_EFriendRelationshipRequestInitiator = 4, + k_EFriendRelationshipIgnored = 5, // this is stored; the user has explicit blocked this other user from comments/chat/etc + k_EFriendRelationshipIgnoredFriend = 6, + k_EFriendRelationshipSuggested_DEPRECATED = 7, // was used by the original implementation of the facebook linking feature, but now unused. + + // keep this updated + k_EFriendRelationshipMax = 8, +}; + +// maximum length of friend group name (not including terminating nul!) +const int k_cchMaxFriendsGroupName = 64; + +// maximum number of groups a single user is allowed +const int k_cFriendsGroupLimit = 100; + +// friends group identifier type +typedef int16 FriendsGroupID_t; + +// invalid friends group identifier constant +const FriendsGroupID_t k_FriendsGroupID_Invalid = -1; + +const int k_cEnumerateFollowersMax = 50; + + +//----------------------------------------------------------------------------- +// Purpose: list of states a friend can be in +//----------------------------------------------------------------------------- +enum EPersonaState +{ + k_EPersonaStateOffline = 0, // friend is not currently logged on + k_EPersonaStateOnline = 1, // friend is logged on + k_EPersonaStateBusy = 2, // user is on, but busy + k_EPersonaStateAway = 3, // auto-away feature + k_EPersonaStateSnooze = 4, // auto-away for a long time + k_EPersonaStateLookingToTrade = 5, // Online, trading + k_EPersonaStateLookingToPlay = 6, // Online, wanting to play + k_EPersonaStateInvisible = 7, // Online, but appears offline to friends. This status is never published to clients. + k_EPersonaStateMax, +}; + + +//----------------------------------------------------------------------------- +// Purpose: flags for enumerating friends list, or quickly checking a the relationship between users +//----------------------------------------------------------------------------- +enum EFriendFlags +{ + k_EFriendFlagNone = 0x00, + k_EFriendFlagBlocked = 0x01, + k_EFriendFlagFriendshipRequested = 0x02, + k_EFriendFlagImmediate = 0x04, // "regular" friend + k_EFriendFlagClanMember = 0x08, + k_EFriendFlagOnGameServer = 0x10, + // k_EFriendFlagHasPlayedWith = 0x20, // not currently used + // k_EFriendFlagFriendOfFriend = 0x40, // not currently used + k_EFriendFlagRequestingFriendship = 0x80, + k_EFriendFlagRequestingInfo = 0x100, + k_EFriendFlagIgnored = 0x200, + k_EFriendFlagIgnoredFriend = 0x400, + // k_EFriendFlagSuggested = 0x800, // not used + k_EFriendFlagChatMember = 0x1000, + k_EFriendFlagAll = 0xFFFF, +}; + + +// friend game played information +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif +struct FriendGameInfo_t +{ + CGameID m_gameID; + uint32 m_unGameIP; + uint16 m_usGamePort; + uint16 m_usQueryPort; + CSteamID m_steamIDLobby; +}; +#pragma pack( pop ) + +// special values for FriendGameInfo_t::m_usQueryPort +const uint16 k_usFriendGameInfoQueryPort_NotInitialized = 0xFFFF; // We haven't asked the GS for this query port's actual value yet. Was #define QUERY_PORT_NOT_INITIALIZED in older versions of Steamworks SDK. +const uint16 k_usFriendGameInfoQueryPort_Error = 0xFFFE; // We were unable to get the query port for this server. Was #define QUERY_PORT_ERROR in older versions of Steamworks SDK. + +// maximum number of characters in a user's name. Two flavors; one for UTF-8 and one for UTF-16. +// The UTF-8 version has to be very generous to accomodate characters that get large when encoded +// in UTF-8. +enum +{ + k_cchPersonaNameMax = 128, + k_cwchPersonaNameMax = 32, +}; + +//----------------------------------------------------------------------------- +// Purpose: user restriction flags +//----------------------------------------------------------------------------- +enum EUserRestriction +{ + k_nUserRestrictionNone = 0, // no known chat/content restriction + k_nUserRestrictionUnknown = 1, // we don't know yet (user offline) + k_nUserRestrictionAnyChat = 2, // user is not allowed to (or can't) send/recv any chat + k_nUserRestrictionVoiceChat = 4, // user is not allowed to (or can't) send/recv voice chat + k_nUserRestrictionGroupChat = 8, // user is not allowed to (or can't) send/recv group chat + k_nUserRestrictionRating = 16, // user is too young according to rating in current region + k_nUserRestrictionGameInvites = 32, // user cannot send or recv game invites (e.g. mobile) + k_nUserRestrictionTrading = 64, // user cannot participate in trading (console, mobile) +}; + +// size limit on chat room or member metadata +const uint32 k_cubChatMetadataMax = 8192; + +// size limits on Rich Presence data +enum { k_cchMaxRichPresenceKeys = 30 }; +enum { k_cchMaxRichPresenceKeyLength = 64 }; +enum { k_cchMaxRichPresenceValueLength = 256 }; + +// These values are passed as parameters to the store +enum EOverlayToStoreFlag +{ + k_EOverlayToStoreFlag_None = 0, + k_EOverlayToStoreFlag_AddToCart = 1, + k_EOverlayToStoreFlag_AddToCartAndShow = 2, +}; + + +//----------------------------------------------------------------------------- +// Purpose: Tells Steam where to place the browser window inside the overlay +//----------------------------------------------------------------------------- +enum EActivateGameOverlayToWebPageMode +{ + k_EActivateGameOverlayToWebPageMode_Default = 0, // Browser will open next to all other windows that the user has open in the overlay. + // The window will remain open, even if the user closes then re-opens the overlay. + + k_EActivateGameOverlayToWebPageMode_Modal = 1 // Browser will be opened in a special overlay configuration which hides all other windows + // that the user has open in the overlay. When the user closes the overlay, the browser window + // will also close. When the user closes the browser window, the overlay will automatically close. +}; + +//----------------------------------------------------------------------------- +// Purpose: See GetProfileItemPropertyString and GetProfileItemPropertyUint +//----------------------------------------------------------------------------- +enum ECommunityProfileItemType +{ + k_ECommunityProfileItemType_AnimatedAvatar = 0, + k_ECommunityProfileItemType_AvatarFrame = 1, + k_ECommunityProfileItemType_ProfileModifier = 2, + k_ECommunityProfileItemType_ProfileBackground = 3, + k_ECommunityProfileItemType_MiniProfileBackground = 4, +}; +enum ECommunityProfileItemProperty +{ + k_ECommunityProfileItemProperty_ImageSmall = 0, // string + k_ECommunityProfileItemProperty_ImageLarge = 1, // string + k_ECommunityProfileItemProperty_InternalName = 2, // string + k_ECommunityProfileItemProperty_Title = 3, // string + k_ECommunityProfileItemProperty_Description = 4, // string + k_ECommunityProfileItemProperty_AppID = 5, // uint32 + k_ECommunityProfileItemProperty_TypeID = 6, // uint32 + k_ECommunityProfileItemProperty_Class = 7, // uint32 + k_ECommunityProfileItemProperty_MovieWebM = 8, // string + k_ECommunityProfileItemProperty_MovieMP4 = 9, // string + k_ECommunityProfileItemProperty_MovieWebMSmall = 10, // string + k_ECommunityProfileItemProperty_MovieMP4Small = 11, // string +}; + +//----------------------------------------------------------------------------- +// Purpose: interface to accessing information about individual users, +// that can be a friend, in a group, on a game server or in a lobby with the local user +//----------------------------------------------------------------------------- +class ISteamFriends +{ +public: + // returns the local players name - guaranteed to not be NULL. + // this is the same name as on the users community profile page + // this is stored in UTF-8 format + // like all the other interface functions that return a char *, it's important that this pointer is not saved + // off; it will eventually be free'd or re-allocated + virtual const char *GetPersonaName() = 0; + + // Sets the player name, stores it on the server and publishes the changes to all friends who are online. + // Changes take place locally immediately, and a PersonaStateChange_t is posted, presuming success. + // + // The final results are available through the return value SteamAPICall_t, using SetPersonaNameResponse_t. + // + // If the name change fails to happen on the server, then an additional global PersonaStateChange_t will be posted + // to change the name back, in addition to the SetPersonaNameResponse_t callback. + STEAM_CALL_RESULT( SetPersonaNameResponse_t ) + virtual SteamAPICall_t SetPersonaName( const char *pchPersonaName ) = 0; + + // gets the status of the current user + virtual EPersonaState GetPersonaState() = 0; + + // friend iteration + // takes a set of k_EFriendFlags, and returns the number of users the client knows about who meet that criteria + // then GetFriendByIndex() can then be used to return the id's of each of those users + virtual int GetFriendCount( int iFriendFlags ) = 0; + + // returns the steamID of a user + // iFriend is a index of range [0, GetFriendCount()) + // iFriendsFlags must be the same value as used in GetFriendCount() + // the returned CSteamID can then be used by all the functions below to access details about the user + virtual CSteamID GetFriendByIndex( int iFriend, int iFriendFlags ) = 0; + + // returns a relationship to a user + virtual EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend ) = 0; + + // returns the current status of the specified user + // this will only be known by the local user if steamIDFriend is in their friends list; on the same game server; in a chat room or lobby; or in a small group with the local user + virtual EPersonaState GetFriendPersonaState( CSteamID steamIDFriend ) = 0; + + // returns the name another user - guaranteed to not be NULL. + // same rules as GetFriendPersonaState() apply as to whether or not the user knowns the name of the other user + // note that on first joining a lobby, chat room or game server the local user will not known the name of the other users automatically; that information will arrive asyncronously + // + virtual const char *GetFriendPersonaName( CSteamID steamIDFriend ) = 0; + + // returns true if the friend is actually in a game, and fills in pFriendGameInfo with an extra details + virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, STEAM_OUT_STRUCT() FriendGameInfo_t *pFriendGameInfo ) = 0; + // accesses old friends names - returns an empty string when their are no more items in the history + virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0; + // friends steam level + virtual int GetFriendSteamLevel( CSteamID steamIDFriend ) = 0; + + // Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player. + // DEPRECATED: GetPersonaName follows the Steam nickname preferences, so apps shouldn't need to care about nicknames explicitly. + virtual const char *GetPlayerNickname( CSteamID steamIDPlayer ) = 0; + + // friend grouping (tag) apis + // returns the number of friends groups + virtual int GetFriendsGroupCount() = 0; + // returns the friends group ID for the given index (invalid indices return k_FriendsGroupID_Invalid) + virtual FriendsGroupID_t GetFriendsGroupIDByIndex( int iFG ) = 0; + // returns the name for the given friends group (NULL in the case of invalid friends group IDs) + virtual const char *GetFriendsGroupName( FriendsGroupID_t friendsGroupID ) = 0; + // returns the number of members in a given friends group + virtual int GetFriendsGroupMembersCount( FriendsGroupID_t friendsGroupID ) = 0; + // gets up to nMembersCount members of the given friends group, if fewer exist than requested those positions' SteamIDs will be invalid + virtual void GetFriendsGroupMembersList( FriendsGroupID_t friendsGroupID, STEAM_OUT_ARRAY_CALL(nMembersCount, GetFriendsGroupMembersCount, friendsGroupID ) CSteamID *pOutSteamIDMembers, int nMembersCount ) = 0; + + // returns true if the specified user meets any of the criteria specified in iFriendFlags + // iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values + virtual bool HasFriend( CSteamID steamIDFriend, int iFriendFlags ) = 0; + + // clan (group) iteration and access functions + virtual int GetClanCount() = 0; + virtual CSteamID GetClanByIndex( int iClan ) = 0; + virtual const char *GetClanName( CSteamID steamIDClan ) = 0; + virtual const char *GetClanTag( CSteamID steamIDClan ) = 0; + // returns the most recent information we have about what's happening in a clan + virtual bool GetClanActivityCounts( CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting ) = 0; + + // for clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest + STEAM_CALL_RESULT( DownloadClanActivityCountsResult_t ) + virtual SteamAPICall_t DownloadClanActivityCounts( STEAM_ARRAY_COUNT(cClansToRequest) CSteamID *psteamIDClans, int cClansToRequest ) = 0; + + // iterators for getting users in a chat room, lobby, game server or clan + // note that large clans that cannot be iterated by the local user + // note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby + // steamIDSource can be the steamID of a group, game server, lobby or chat room + virtual int GetFriendCountFromSource( CSteamID steamIDSource ) = 0; + virtual CSteamID GetFriendFromSourceByIndex( CSteamID steamIDSource, int iFriend ) = 0; + + // returns true if the local user can see that steamIDUser is a member or in steamIDSource + virtual bool IsUserInSource( CSteamID steamIDUser, CSteamID steamIDSource ) = 0; + + // User is in a game pressing the talk button (will suppress the microphone for all voice comms from the Steam friends UI) + virtual void SetInGameVoiceSpeaking( CSteamID steamIDUser, bool bSpeaking ) = 0; + + // activates the game overlay, with an optional dialog to open + // valid options include "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements", + // "chatroomgroup/nnnn" + virtual void ActivateGameOverlay( const char *pchDialog ) = 0; + + // activates game overlay to a specific place + // valid options are + // "steamid" - opens the overlay web browser to the specified user or groups profile + // "chat" - opens a chat window to the specified user, or joins the group chat + // "jointrade" - opens a window to a Steam Trading session that was started with the ISteamEconomy/StartTrade Web API + // "stats" - opens the overlay web browser to the specified user's stats + // "achievements" - opens the overlay web browser to the specified user's achievements + // "friendadd" - opens the overlay in minimal mode prompting the user to add the target user as a friend + // "friendremove" - opens the overlay in minimal mode prompting the user to remove the target friend + // "friendrequestaccept" - opens the overlay in minimal mode prompting the user to accept an incoming friend invite + // "friendrequestignore" - opens the overlay in minimal mode prompting the user to ignore an incoming friend invite + virtual void ActivateGameOverlayToUser( const char *pchDialog, CSteamID steamID ) = 0; + + // activates game overlay web browser directly to the specified URL + // full address with protocol type is required, e.g. http://www.steamgames.com/ + virtual void ActivateGameOverlayToWebPage( const char *pchURL, EActivateGameOverlayToWebPageMode eMode = k_EActivateGameOverlayToWebPageMode_Default ) = 0; + + // activates game overlay to store page for app + virtual void ActivateGameOverlayToStore( AppId_t nAppID, EOverlayToStoreFlag eFlag ) = 0; + + // Mark a target user as 'played with'. This is a client-side only feature that requires that the calling user is + // in game + virtual void SetPlayedWith( CSteamID steamIDUserPlayedWith ) = 0; + + // activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby. + virtual void ActivateGameOverlayInviteDialog( CSteamID steamIDLobby ) = 0; + + // gets the small (32x32) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set + virtual int GetSmallFriendAvatar( CSteamID steamIDFriend ) = 0; + + // gets the medium (64x64) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set + virtual int GetMediumFriendAvatar( CSteamID steamIDFriend ) = 0; + + // gets the large (184x184) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set + // returns -1 if this image has yet to be loaded, in this case wait for a AvatarImageLoaded_t callback and then call this again + virtual int GetLargeFriendAvatar( CSteamID steamIDFriend ) = 0; + + // requests information about a user - persona name & avatar + // if bRequireNameOnly is set, then the avatar of a user isn't downloaded + // - it's a lot slower to download avatars and churns the local cache, so if you don't need avatars, don't request them + // if returns true, it means that data is being requested, and a PersonaStateChanged_t callback will be posted when it's retrieved + // if returns false, it means that we already have all the details about that user, and functions can be called immediately + virtual bool RequestUserInformation( CSteamID steamIDUser, bool bRequireNameOnly ) = 0; + + // requests information about a clan officer list + // when complete, data is returned in ClanOfficerListResponse_t call result + // this makes available the calls below + // you can only ask about clans that a user is a member of + // note that this won't download avatars automatically; if you get an officer, + // and no avatar image is available, call RequestUserInformation( steamID, false ) to download the avatar + STEAM_CALL_RESULT( ClanOfficerListResponse_t ) + virtual SteamAPICall_t RequestClanOfficerList( CSteamID steamIDClan ) = 0; + + // iteration of clan officers - can only be done when a RequestClanOfficerList() call has completed + + // returns the steamID of the clan owner + virtual CSteamID GetClanOwner( CSteamID steamIDClan ) = 0; + // returns the number of officers in a clan (including the owner) + virtual int GetClanOfficerCount( CSteamID steamIDClan ) = 0; + // returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount) + virtual CSteamID GetClanOfficerByIndex( CSteamID steamIDClan, int iOfficer ) = 0; + // if current user is chat restricted, he can't send or receive any text/voice chat messages. + // the user can't see custom avatars. But the user can be online and send/recv game invites. + // a chat restricted user can't add friends or join any groups. + virtual uint32 GetUserRestrictions() = 0; + + // Rich Presence data is automatically shared between friends who are in the same game + // Each user has a set of Key/Value pairs + // Note the following limits: k_cchMaxRichPresenceKeys, k_cchMaxRichPresenceKeyLength, k_cchMaxRichPresenceValueLength + // There are five magic keys: + // "status" - a UTF-8 string that will show up in the 'view game info' dialog in the Steam friends list + // "connect" - a UTF-8 string that contains the command-line for how a friend can connect to a game + // "steam_display" - Names a rich presence localization token that will be displayed in the viewing user's selected language + // in the Steam client UI. For more info: https://partner.steamgames.com/doc/api/ISteamFriends#richpresencelocalization + // "steam_player_group" - When set, indicates to the Steam client that the player is a member of a particular group. Players in the same group + // may be organized together in various places in the Steam UI. + // "steam_player_group_size" - When set, indicates the total number of players in the steam_player_group. The Steam client may use this number to + // display additional information about a group when all of the members are not part of a user's friends list. + // GetFriendRichPresence() returns an empty string "" if no value is set + // SetRichPresence() to a NULL or an empty string deletes the key + // You can iterate the current set of keys for a friend with GetFriendRichPresenceKeyCount() + // and GetFriendRichPresenceKeyByIndex() (typically only used for debugging) + virtual bool SetRichPresence( const char *pchKey, const char *pchValue ) = 0; + virtual void ClearRichPresence() = 0; + virtual const char *GetFriendRichPresence( CSteamID steamIDFriend, const char *pchKey ) = 0; + virtual int GetFriendRichPresenceKeyCount( CSteamID steamIDFriend ) = 0; + virtual const char *GetFriendRichPresenceKeyByIndex( CSteamID steamIDFriend, int iKey ) = 0; + // Requests rich presence for a specific user. + virtual void RequestFriendRichPresence( CSteamID steamIDFriend ) = 0; + + // Rich invite support. + // If the target accepts the invite, a GameRichPresenceJoinRequested_t callback is posted containing the connect string. + // (Or you can configure your game so that it is passed on the command line instead. This is a deprecated path; ask us if you really need this.) + virtual bool InviteUserToGame( CSteamID steamIDFriend, const char *pchConnectString ) = 0; + + // recently-played-with friends iteration + // this iterates the entire list of users recently played with, across games + // GetFriendCoplayTime() returns as a unix time + virtual int GetCoplayFriendCount() = 0; + virtual CSteamID GetCoplayFriend( int iCoplayFriend ) = 0; + virtual int GetFriendCoplayTime( CSteamID steamIDFriend ) = 0; + virtual AppId_t GetFriendCoplayGame( CSteamID steamIDFriend ) = 0; + + // chat interface for games + // this allows in-game access to group (clan) chats from in the game + // the behavior is somewhat sophisticated, because the user may or may not be already in the group chat from outside the game or in the overlay + // use ActivateGameOverlayToUser( "chat", steamIDClan ) to open the in-game overlay version of the chat + STEAM_CALL_RESULT( JoinClanChatRoomCompletionResult_t ) + virtual SteamAPICall_t JoinClanChatRoom( CSteamID steamIDClan ) = 0; + virtual bool LeaveClanChatRoom( CSteamID steamIDClan ) = 0; + virtual int GetClanChatMemberCount( CSteamID steamIDClan ) = 0; + virtual CSteamID GetChatMemberByIndex( CSteamID steamIDClan, int iUser ) = 0; + virtual bool SendClanChatMessage( CSteamID steamIDClanChat, const char *pchText ) = 0; + virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, STEAM_OUT_STRUCT() CSteamID *psteamidChatter ) = 0; + virtual bool IsClanChatAdmin( CSteamID steamIDClanChat, CSteamID steamIDUser ) = 0; + + // interact with the Steam (game overlay / desktop) + virtual bool IsClanChatWindowOpenInSteam( CSteamID steamIDClanChat ) = 0; + virtual bool OpenClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0; + virtual bool CloseClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0; + + // peer-to-peer chat interception + // this is so you can show P2P chats inline in the game + virtual bool SetListenForFriendsMessages( bool bInterceptEnabled ) = 0; + virtual bool ReplyToFriendMessage( CSteamID steamIDFriend, const char *pchMsgToSend ) = 0; + virtual int GetFriendMessage( CSteamID steamIDFriend, int iMessageID, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0; + + // following apis + STEAM_CALL_RESULT( FriendsGetFollowerCount_t ) + virtual SteamAPICall_t GetFollowerCount( CSteamID steamID ) = 0; + STEAM_CALL_RESULT( FriendsIsFollowing_t ) + virtual SteamAPICall_t IsFollowing( CSteamID steamID ) = 0; + STEAM_CALL_RESULT( FriendsEnumerateFollowingList_t ) + virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0; + + virtual bool IsClanPublic( CSteamID steamIDClan ) = 0; + virtual bool IsClanOfficialGameGroup( CSteamID steamIDClan ) = 0; + + /// Return the number of chats (friends or chat rooms) with unread messages. + /// A "priority" message is one that would generate some sort of toast or + /// notification, and depends on user settings. + /// + /// You can register for UnreadChatMessagesChanged_t callbacks to know when this + /// has potentially changed. + virtual int GetNumChatsWithUnreadPriorityMessages() = 0; + + // activates game overlay to open the remote play together invite dialog. Invitations will be sent for remote play together + virtual void ActivateGameOverlayRemotePlayTogetherInviteDialog( CSteamID steamIDLobby ) = 0; + + // Call this before calling ActivateGameOverlayToWebPage() to have the Steam Overlay Browser block navigations + // to your specified protocol (scheme) uris and instead dispatch a OverlayBrowserProtocolNavigation_t callback to your game. + // ActivateGameOverlayToWebPage() must have been called with k_EActivateGameOverlayToWebPageMode_Modal + virtual bool RegisterProtocolInOverlayBrowser( const char *pchProtocol ) = 0; + + // Activates the game overlay to open an invite dialog that will send the provided Rich Presence connect string to selected friends + virtual void ActivateGameOverlayInviteDialogConnectString( const char *pchConnectString ) = 0; + + // Steam Community items equipped by a user on their profile + // You can register for EquippedProfileItemsChanged_t to know when a friend has changed their equipped profile items + STEAM_CALL_RESULT( EquippedProfileItems_t ) + virtual SteamAPICall_t RequestEquippedProfileItems( CSteamID steamID ) = 0; + virtual bool BHasEquippedProfileItem( CSteamID steamID, ECommunityProfileItemType itemType ) = 0; + virtual const char *GetProfileItemPropertyString( CSteamID steamID, ECommunityProfileItemType itemType, ECommunityProfileItemProperty prop ) = 0; + virtual uint32 GetProfileItemPropertyUint( CSteamID steamID, ECommunityProfileItemType itemType, ECommunityProfileItemProperty prop ) = 0; +}; + +#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends017" + +// Global interface accessor +inline ISteamFriends *SteamFriends(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamFriends *, SteamFriends, STEAMFRIENDS_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: called when a friends' status changes +//----------------------------------------------------------------------------- +struct PersonaStateChange_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 4 }; + + uint64 m_ulSteamID; // steamID of the friend who changed + int m_nChangeFlags; // what's changed +}; + + +// used in PersonaStateChange_t::m_nChangeFlags to describe what's changed about a user +// these flags describe what the client has learned has changed recently, so on startup you'll see a name, avatar & relationship change for every friend +enum EPersonaChange +{ + k_EPersonaChangeName = 0x0001, + k_EPersonaChangeStatus = 0x0002, + k_EPersonaChangeComeOnline = 0x0004, + k_EPersonaChangeGoneOffline = 0x0008, + k_EPersonaChangeGamePlayed = 0x0010, + k_EPersonaChangeGameServer = 0x0020, + k_EPersonaChangeAvatar = 0x0040, + k_EPersonaChangeJoinedSource= 0x0080, + k_EPersonaChangeLeftSource = 0x0100, + k_EPersonaChangeRelationshipChanged = 0x0200, + k_EPersonaChangeNameFirstSet = 0x0400, + k_EPersonaChangeBroadcast = 0x0800, + k_EPersonaChangeNickname = 0x1000, + k_EPersonaChangeSteamLevel = 0x2000, + k_EPersonaChangeRichPresence = 0x4000, +}; + + +//----------------------------------------------------------------------------- +// Purpose: posted when game overlay activates or deactivates +// the game can use this to be pause or resume single player games +//----------------------------------------------------------------------------- +struct GameOverlayActivated_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 31 }; + uint8 m_bActive; // true if it's just been activated, false otherwise + bool m_bUserInitiated; // true if the user asked for the overlay to be activated/deactivated + AppId_t m_nAppID; // the appID of the game (should always be the current game) + uint32 m_dwOverlayPID; // used internally +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when the user tries to join a different game server from their friends list +// game client should attempt to connect to specified server when this is received +//----------------------------------------------------------------------------- +struct GameServerChangeRequested_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 32 }; + char m_rgchServer[64]; // server address ("127.0.0.1:27015", "tf2.valvesoftware.com") + char m_rgchPassword[64]; // server password, if any +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when the user tries to join a lobby from their friends list +// game client should attempt to connect to specified lobby when this is received +//----------------------------------------------------------------------------- +struct GameLobbyJoinRequested_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 33 }; + CSteamID m_steamIDLobby; + + // The friend they did the join via (will be invalid if not directly via a friend) + // + // On PS3, the friend will be invalid if this was triggered by a PSN invite via the XMB, but + // the account type will be console user so you can tell at least that this was from a PSN friend + // rather than a Steam friend. + CSteamID m_steamIDFriend; +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when an avatar is loaded in from a previous GetLargeFriendAvatar() call +// if the image wasn't already available +//----------------------------------------------------------------------------- +struct AvatarImageLoaded_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 34 }; + CSteamID m_steamID; // steamid the avatar has been loaded for + int m_iImage; // the image index of the now loaded image + int m_iWide; // width of the loaded image + int m_iTall; // height of the loaded image +}; + + +//----------------------------------------------------------------------------- +// Purpose: marks the return of a request officer list call +//----------------------------------------------------------------------------- +struct ClanOfficerListResponse_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 35 }; + CSteamID m_steamIDClan; + int m_cOfficers; + uint8 m_bSuccess; +}; + + +//----------------------------------------------------------------------------- +// Purpose: callback indicating updated data about friends rich presence information +//----------------------------------------------------------------------------- +struct FriendRichPresenceUpdate_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 36 }; + CSteamID m_steamIDFriend; // friend who's rich presence has changed + AppId_t m_nAppID; // the appID of the game (should always be the current game) +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when the user tries to join a game from their friends list +// rich presence will have been set with the "connect" key which is set here +//----------------------------------------------------------------------------- +struct GameRichPresenceJoinRequested_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 37 }; + CSteamID m_steamIDFriend; // the friend they did the join via (will be invalid if not directly via a friend) + char m_rgchConnect[k_cchMaxRichPresenceValueLength]; +}; + + +//----------------------------------------------------------------------------- +// Purpose: a chat message has been received for a clan chat the game has joined +//----------------------------------------------------------------------------- +struct GameConnectedClanChatMsg_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 38 }; + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; + int m_iMessageID; +}; + + +//----------------------------------------------------------------------------- +// Purpose: a user has joined a clan chat +//----------------------------------------------------------------------------- +struct GameConnectedChatJoin_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 39 }; + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; +}; + + +//----------------------------------------------------------------------------- +// Purpose: a user has left the chat we're in +//----------------------------------------------------------------------------- +struct GameConnectedChatLeave_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 40 }; + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; + bool m_bKicked; // true if admin kicked + bool m_bDropped; // true if Steam connection dropped +}; + + +//----------------------------------------------------------------------------- +// Purpose: a DownloadClanActivityCounts() call has finished +//----------------------------------------------------------------------------- +struct DownloadClanActivityCountsResult_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 41 }; + bool m_bSuccess; +}; + + +//----------------------------------------------------------------------------- +// Purpose: a JoinClanChatRoom() call has finished +//----------------------------------------------------------------------------- +struct JoinClanChatRoomCompletionResult_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 42 }; + CSteamID m_steamIDClanChat; + EChatRoomEnterResponse m_eChatRoomEnterResponse; +}; + +//----------------------------------------------------------------------------- +// Purpose: a chat message has been received from a user +//----------------------------------------------------------------------------- +struct GameConnectedFriendChatMsg_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 43 }; + CSteamID m_steamIDUser; + int m_iMessageID; +}; + + +struct FriendsGetFollowerCount_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 44 }; + EResult m_eResult; + CSteamID m_steamID; + int m_nCount; +}; + + +struct FriendsIsFollowing_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 45 }; + EResult m_eResult; + CSteamID m_steamID; + bool m_bIsFollowing; +}; + + +struct FriendsEnumerateFollowingList_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 46 }; + EResult m_eResult; + CSteamID m_rgSteamID[ k_cEnumerateFollowersMax ]; + int32 m_nResultsReturned; + int32 m_nTotalResultCount; +}; + +//----------------------------------------------------------------------------- +// Purpose: reports the result of an attempt to change the user's persona name +//----------------------------------------------------------------------------- +struct SetPersonaNameResponse_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 47 }; + + bool m_bSuccess; // true if name change succeeded completely. + bool m_bLocalSuccess; // true if name change was retained locally. (We might not have been able to communicate with Steam) + EResult m_result; // detailed result code +}; + +//----------------------------------------------------------------------------- +// Purpose: Invoked when the status of unread messages changes +//----------------------------------------------------------------------------- +struct UnreadChatMessagesChanged_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 48 }; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Dispatched when an overlay browser instance is navigated to a protocol/scheme registered by RegisterProtocolInOverlayBrowser() +//----------------------------------------------------------------------------- +struct OverlayBrowserProtocolNavigation_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 49 }; + char rgchURI[ 1024 ]; +}; + +//----------------------------------------------------------------------------- +// Purpose: A user's equipped profile items have changed +//----------------------------------------------------------------------------- +struct EquippedProfileItemsChanged_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 50 }; + CSteamID m_steamID; +}; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +struct EquippedProfileItems_t +{ + enum { k_iCallback = k_iSteamFriendsCallbacks + 51 }; + EResult m_eResult; + CSteamID m_steamID; + bool m_bHasAnimatedAvatar; + bool m_bHasAvatarFrame; + bool m_bHasProfileModifier; + bool m_bHasProfileBackground; + bool m_bHasMiniProfileBackground; +}; + +#pragma pack( pop ) + +#endif // ISTEAMFRIENDS_H diff --git a/lsteamclient/steamworks_sdk_160/isteamgamecoordinator.h b/lsteamclient/steamworks_sdk_160/isteamgamecoordinator.h new file mode 100644 index 0000000000..89b740d7ce --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamgamecoordinator.h @@ -0,0 +1,74 @@ +//====== Copyright ©, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to the game coordinator for this application +// +//============================================================================= + +#ifndef ISTEAMGAMECOORDINATOR +#define ISTEAMGAMECOORDINATOR +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + + +// list of possible return values from the ISteamGameCoordinator API +enum EGCResults +{ + k_EGCResultOK = 0, + k_EGCResultNoMessage = 1, // There is no message in the queue + k_EGCResultBufferTooSmall = 2, // The buffer is too small for the requested message + k_EGCResultNotLoggedOn = 3, // The client is not logged onto Steam + k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage +}; + + +//----------------------------------------------------------------------------- +// Purpose: Functions for sending and receiving messages from the Game Coordinator +// for this application +//----------------------------------------------------------------------------- +class ISteamGameCoordinator +{ +public: + + // sends a message to the Game Coordinator + virtual EGCResults SendMessage( uint32 unMsgType, const void *pubData, uint32 cubData ) = 0; + + // returns true if there is a message waiting from the game coordinator + virtual bool IsMessageAvailable( uint32 *pcubMsgSize ) = 0; + + // fills the provided buffer with the first message in the queue and returns k_EGCResultOK or + // returns k_EGCResultNoMessage if there is no message waiting. pcubMsgSize is filled with the message size. + // If the provided buffer is not large enough to fit the entire message, k_EGCResultBufferTooSmall is returned + // and the message remains at the head of the queue. + virtual EGCResults RetrieveMessage( uint32 *punMsgType, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0; + +}; +#define STEAMGAMECOORDINATOR_INTERFACE_VERSION "SteamGameCoordinator001" + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +// callback notification - A new message is available for reading from the message queue +struct GCMessageAvailable_t +{ + enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 1 }; + uint32 m_nMessageSize; +}; + +// callback notification - A message failed to make it to the GC. It may be down temporarily +struct GCMessageFailed_t +{ + enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 2 }; +}; + +#pragma pack( pop ) + +#endif // ISTEAMGAMECOORDINATOR diff --git a/lsteamclient/steamworks_sdk_160/isteamgameserver.h b/lsteamclient/steamworks_sdk_160/isteamgameserver.h new file mode 100644 index 0000000000..ba4d12517f --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamgameserver.h @@ -0,0 +1,394 @@ +//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to steam for game servers +// +//============================================================================= + +#ifndef ISTEAMGAMESERVER_H +#define ISTEAMGAMESERVER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: Functions for authenticating users via Steam to play on a game server +//----------------------------------------------------------------------------- +class ISteamGameServer +{ +public: + +// +// Basic server data. These properties, if set, must be set before before calling LogOn. They +// may not be changed after logged in. +// + + /// This is called by SteamGameServer_Init, and you will usually not need to call it directly + STEAM_PRIVATE_API( virtual bool InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString ) = 0; ) + + /// Game product identifier. This is currently used by the master server for version checking purposes. + /// It's a required field, but will eventually will go away, and the AppID will be used for this purpose. + virtual void SetProduct( const char *pszProduct ) = 0; + + /// Description of the game. This is a required field and is displayed in the steam server browser....for now. + /// This is a required field, but it will go away eventually, as the data should be determined from the AppID. + virtual void SetGameDescription( const char *pszGameDescription ) = 0; + + /// If your game is a "mod," pass the string that identifies it. The default is an empty string, meaning + /// this application is the original game, not a mod. + /// + /// @see k_cbMaxGameServerGameDir + virtual void SetModDir( const char *pszModDir ) = 0; + + /// Is this is a dedicated server? The default value is false. + virtual void SetDedicatedServer( bool bDedicated ) = 0; + +// +// Login +// + + /// Begin process to login to a persistent game server account + /// + /// You need to register for callbacks to determine the result of this operation. + /// @see SteamServersConnected_t + /// @see SteamServerConnectFailure_t + /// @see SteamServersDisconnected_t + virtual void LogOn( const char *pszToken ) = 0; + + /// Login to a generic, anonymous account. + /// + /// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init, + /// but this is no longer the case. + virtual void LogOnAnonymous() = 0; + + /// Begin process of logging game server out of steam + virtual void LogOff() = 0; + + // status functions + virtual bool BLoggedOn() = 0; + virtual bool BSecure() = 0; + virtual CSteamID GetSteamID() = 0; + + /// Returns true if the master server has requested a restart. + /// Only returns true once per request. + virtual bool WasRestartRequested() = 0; + +// +// Server state. These properties may be changed at any time. +// + + /// Max player count that will be reported to server browser and client queries + virtual void SetMaxPlayerCount( int cPlayersMax ) = 0; + + /// Number of bots. Default value is zero + virtual void SetBotPlayerCount( int cBotplayers ) = 0; + + /// Set the name of server as it will appear in the server browser + /// + /// @see k_cbMaxGameServerName + virtual void SetServerName( const char *pszServerName ) = 0; + + /// Set name of map to report in the server browser + /// + /// @see k_cbMaxGameServerMapName + virtual void SetMapName( const char *pszMapName ) = 0; + + /// Let people know if your server will require a password + virtual void SetPasswordProtected( bool bPasswordProtected ) = 0; + + /// Spectator server port to advertise. The default value is zero, meaning the + /// service is not used. If your server receives any info requests on the LAN, + /// this is the value that will be placed into the reply for such local queries. + /// + /// This is also the value that will be advertised by the master server. + /// The only exception is if your server is using a FakeIP. Then then the second + /// fake port number (index 1) assigned to your server will be listed on the master + /// server as the spectator port, if you set this value to any nonzero value. + /// + /// This function merely controls the values that are advertised -- it's up to you to + /// configure the server to actually listen on this port and handle any spectator traffic + virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0; + + /// Name of the spectator server. (Only used if spectator port is nonzero.) + /// + /// @see k_cbMaxGameServerMapName + virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0; + + /// Call this to clear the whole list of key/values that are sent in rules queries. + virtual void ClearAllKeyValues() = 0; + + /// Call this to add/update a key/value pair. + virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0; + + /// Sets a string defining the "gametags" for this server, this is optional, but if it is set + /// it allows users to filter in the matchmaking/server-browser interfaces based on the value + /// + /// @see k_cbMaxGameServerTags + virtual void SetGameTags( const char *pchGameTags ) = 0; + + /// Sets a string defining the "gamedata" for this server, this is optional, but if it is set + /// it allows users to filter in the matchmaking/server-browser interfaces based on the value + /// + /// @see k_cbMaxGameServerGameData + virtual void SetGameData( const char *pchGameData ) = 0; + + /// Region identifier. This is an optional field, the default value is empty, meaning the "world" region + virtual void SetRegion( const char *pszRegion ) = 0; + + /// Indicate whether you wish to be listed on the master server list + /// and/or respond to server browser / LAN discovery packets. + /// The server starts with this value set to false. You should set all + /// relevant server parameters before enabling advertisement on the server. + /// + /// (This function used to be named EnableHeartbeats, so if you are wondering + /// where that function went, it's right here. It does the same thing as before, + /// the old name was just confusing.) + virtual void SetAdvertiseServerActive( bool bActive ) = 0; + +// +// Player list management / authentication. +// + + // Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). + // pcbTicket retrieves the length of the actual ticket. + // SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to + // if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address + virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid ) = 0; + + // Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused + // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse ) + virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0; + + // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity + virtual void EndAuthSession( CSteamID steamID ) = 0; + + // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to + virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0; + + // After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function + // to determine if the user owns downloadable content specified by the provided AppID. + virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0; + + // Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t + // returns false if we're not connected to the steam servers and thus cannot ask + virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0; + + + // these two functions s are deprecated, and will not return results + // they will be removed in a future version of the SDK + virtual void GetGameplayStats( ) = 0; + STEAM_CALL_RESULT( GSReputation_t ) + virtual SteamAPICall_t GetServerReputation() = 0; + + // Returns the public IP of the server according to Steam, useful when the server is + // behind NAT and you want to advertise its IP in a lobby for other clients to directly + // connect to + virtual SteamIPAddress_t GetPublicIP() = 0; + +// Server browser related query packet processing for shared socket mode. These are used +// when you pass STEAMGAMESERVER_QUERY_PORT_SHARED as the query port to SteamGameServer_Init. +// IP address and port are in host order, i.e 127.0.0.1 == 0x7f000001 + + // These are used when you've elected to multiplex the game server's UDP socket + // rather than having the master server updater use its own sockets. + // + // Source games use this to simplify the job of the server admins, so they + // don't have to open up more ports on their firewalls. + + // Call this when a packet that starts with 0xFFFFFFFF comes in. That means + // it's for us. + virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0; + + // AFTER calling HandleIncomingPacket for any packets that came in that frame, call this. + // This gets a packet that the master server updater needs to send out on UDP. + // It returns the length of the packet it wants to send, or 0 if there are no more packets to send. + // Call this each frame until it returns 0. + virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0; + +// +// Server clan association +// + + // associate this game server with this clan for the purposes of computing player compat + STEAM_CALL_RESULT( AssociateWithClanResult_t ) + virtual SteamAPICall_t AssociateWithClan( CSteamID steamIDClan ) = 0; + + // ask if any of the current players dont want to play with this new player - or vice versa + STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t ) + virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0; + + + + + // Handles receiving a new connection from a Steam user. This call will ask the Steam + // servers to validate the users identity, app ownership, and VAC status. If the Steam servers + // are off-line, then it will validate the cached ticket itself which will validate app ownership + // and identity. The AuthBlob here should be acquired on the game client using SteamUser()->InitiateGameConnection() + // and must then be sent up to the game server for authentication. + // + // Return Value: returns true if the users ticket passes basic checks. pSteamIDUser will contain the Steam ID of this user. pSteamIDUser must NOT be NULL + // If the call succeeds then you should expect a GSClientApprove_t or GSClientDeny_t callback which will tell you whether authentication + // for the user has succeeded or failed (the steamid in the callback will match the one returned by this call) + // + // DEPRECATED! This function will be removed from the SDK in an upcoming version. + // Please migrate to BeginAuthSession and related functions. + virtual bool SendUserConnectAndAuthenticate_DEPRECATED( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0; + + // Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation. + // + // Return Value: Returns a SteamID for the user to be tracked with, you should call EndAuthSession() + // when this user leaves the server just like you would for a real user. + virtual CSteamID CreateUnauthenticatedUserConnection() = 0; + + // Should be called whenever a user leaves our game server, this lets Steam internally + // track which users are currently on which servers for the purposes of preventing a single + // account being logged into multiple servers, showing who is currently on a server, etc. + // + // DEPRECATED! This function will be removed from the SDK in an upcoming version. + // Please migrate to BeginAuthSession and related functions. + virtual void SendUserDisconnect_DEPRECATED( CSteamID steamIDUser ) = 0; + + // Update the data to be displayed in the server browser and matchmaking interfaces for a user + // currently connected to the server. For regular users you must call this after you receive a + // GSUserValidationSuccess callback. + // + // Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player) + virtual bool BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) = 0; + +// Deprecated functions. These will be removed in a future version of the SDK. +// If you really need these, please contact us and help us understand what you are +// using them for. + + STEAM_PRIVATE_API( + virtual void SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) = 0; + virtual void ForceMasterServerHeartbeat_DEPRECATED() = 0; + ) +}; + +#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer015" + +// Global accessor +inline ISteamGameServer *SteamGameServer(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServer *, SteamGameServer, STEAMGAMESERVER_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +// client has been approved to connect to this game server +struct GSClientApprove_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 1 }; + CSteamID m_SteamID; // SteamID of approved player + CSteamID m_OwnerSteamID; // SteamID of original owner for game license +}; + + +// client has been denied to connection to this game server +struct GSClientDeny_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 2 }; + CSteamID m_SteamID; + EDenyReason m_eDenyReason; + char m_rgchOptionalText[128]; +}; + + +// request the game server should kick the user +struct GSClientKick_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 3 }; + CSteamID m_SteamID; + EDenyReason m_eDenyReason; +}; + +// NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks, +// do not reuse them here. + + +// client achievement info +struct GSClientAchievementStatus_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 6 }; + uint64 m_SteamID; + char m_pchAchievement[128]; + bool m_bUnlocked; +}; + +// received when the game server requests to be displayed as secure (VAC protected) +// m_bSecure is true if the game server should display itself as secure to users, false otherwise +struct GSPolicyResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 15 }; + uint8 m_bSecure; +}; + +// GS gameplay stats info +struct GSGameplayStats_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 7 }; + EResult m_eResult; // Result of the call + int32 m_nRank; // Overall rank of the server (0-based) + uint32 m_unTotalConnects; // Total number of clients who have ever connected to the server + uint32 m_unTotalMinutesPlayed; // Total number of minutes ever played on the server +}; + +// send as a reply to RequestUserGroupStatus() +struct GSClientGroupStatus_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 8 }; + CSteamID m_SteamIDUser; + CSteamID m_SteamIDGroup; + bool m_bMember; + bool m_bOfficer; +}; + +// Sent as a reply to GetServerReputation() +struct GSReputation_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 9 }; + EResult m_eResult; // Result of the call; + uint32 m_unReputationScore; // The reputation score for the game server + bool m_bBanned; // True if the server is banned from the Steam + // master servers + + // The following members are only filled out if m_bBanned is true. They will all + // be set to zero otherwise. Master server bans are by IP so it is possible to be + // banned even when the score is good high if there is a bad server on another port. + // This information can be used to determine which server is bad. + + uint32 m_unBannedIP; // The IP of the banned server + uint16 m_usBannedPort; // The port of the banned server + uint64 m_ulBannedGameID; // The game ID the banned server is serving + uint32 m_unBanExpires; // Time the ban expires, expressed in the Unix epoch (seconds since 1/1/1970) +}; + +// Sent as a reply to AssociateWithClan() +struct AssociateWithClanResult_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 10 }; + EResult m_eResult; // Result of the call; +}; + +// Sent as a reply to ComputeNewPlayerCompatibility() +struct ComputeNewPlayerCompatibilityResult_t +{ + enum { k_iCallback = k_iSteamGameServerCallbacks + 11 }; + EResult m_eResult; // Result of the call; + int m_cPlayersThatDontLikeCandidate; + int m_cPlayersThatCandidateDoesntLike; + int m_cClanPlayersThatDontLikeCandidate; + CSteamID m_SteamIDCandidate; +}; + + +#pragma pack( pop ) + +#endif // ISTEAMGAMESERVER_H diff --git a/lsteamclient/steamworks_sdk_160/isteamgameserverstats.h b/lsteamclient/steamworks_sdk_160/isteamgameserverstats.h new file mode 100644 index 0000000000..50192794e1 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamgameserverstats.h @@ -0,0 +1,114 @@ +//====== Copyright © Valve Corporation, All rights reserved. ======= +// +// Purpose: interface for game servers to steam stats and achievements +// +//============================================================================= + +#ifndef ISTEAMGAMESERVERSTATS_H +#define ISTEAMGAMESERVERSTATS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: Functions for authenticating users via Steam to play on a game server +//----------------------------------------------------------------------------- +class ISteamGameServerStats +{ +public: + // downloads stats for the user + // returns a GSStatsReceived_t callback when completed + // if the user has no stats, GSStatsReceived_t.m_eResult will be set to k_EResultFail + // these stats will only be auto-updated for clients playing on the server. For other + // users you'll need to call RequestUserStats() again to refresh any data + STEAM_CALL_RESULT( GSStatsReceived_t ) + virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0; + + // requests stat information for a user, usable after a successful call to RequestUserStats() + STEAM_FLAT_NAME( GetUserStatInt32 ) + virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0; + + STEAM_FLAT_NAME( GetUserStatFloat ) + virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0; + + virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0; + + // Set / update stats and achievements. + // Note: These updates will work only on stats game servers are allowed to edit and only for + // game servers that have been declared as officially controlled by the game creators. + // Set the IP range of your official servers on the Steamworks page + + STEAM_FLAT_NAME( SetUserStatInt32 ) + virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData ) = 0; + + STEAM_FLAT_NAME( SetUserStatFloat ) + virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, float fData ) = 0; + + virtual bool UpdateUserAvgRateStat( CSteamID steamIDUser, const char *pchName, float flCountThisSession, double dSessionLength ) = 0; + + virtual bool SetUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0; + virtual bool ClearUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0; + + // Store the current data on the server, will get a GSStatsStored_t callback when set. + // + // If the callback has a result of k_EResultInvalidParam, one or more stats + // uploaded has been rejected, either because they broke constraints + // or were out of date. In this case the server sends back updated values. + // The stats should be re-iterated to keep in sync. + STEAM_CALL_RESULT( GSStatsStored_t ) + virtual SteamAPICall_t StoreUserStats( CSteamID steamIDUser ) = 0; +}; +#define STEAMGAMESERVERSTATS_INTERFACE_VERSION "SteamGameServerStats001" + +// Global accessor +inline ISteamGameServerStats *SteamGameServerStats(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServerStats *, SteamGameServerStats, STEAMGAMESERVERSTATS_INTERFACE_VERSION ); + + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: called when the latests stats and achievements have been received +// from the server +//----------------------------------------------------------------------------- +struct GSStatsReceived_t +{ + enum { k_iCallback = k_iSteamGameServerStatsCallbacks }; + EResult m_eResult; // Success / error fetching the stats + CSteamID m_steamIDUser; // The user for whom the stats are retrieved for +}; + + +//----------------------------------------------------------------------------- +// Purpose: result of a request to store the user stats for a game +//----------------------------------------------------------------------------- +struct GSStatsStored_t +{ + enum { k_iCallback = k_iSteamGameServerStatsCallbacks + 1 }; + EResult m_eResult; // success / error + CSteamID m_steamIDUser; // The user for whom the stats were stored +}; + +//----------------------------------------------------------------------------- +// Purpose: Callback indicating that a user's stats have been unloaded. +// Call RequestUserStats again to access stats for this user +//----------------------------------------------------------------------------- +struct GSStatsUnloaded_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 }; + CSteamID m_steamIDUser; // User whose stats have been unloaded +}; + +#pragma pack( pop ) + + +#endif // ISTEAMGAMESERVERSTATS_H diff --git a/lsteamclient/steamworks_sdk_160/isteamhtmlsurface.h b/lsteamclient/steamworks_sdk_160/isteamhtmlsurface.h new file mode 100644 index 0000000000..dd30fe249d --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamhtmlsurface.h @@ -0,0 +1,479 @@ +//====== Copyright 1996-2013, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to display html pages in a texture +// +//============================================================================= + +#ifndef ISTEAMHTMLSURFACE_H +#define ISTEAMHTMLSURFACE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +typedef uint32 HHTMLBrowser; +const uint32 INVALID_HTMLBROWSER = 0; + +//----------------------------------------------------------------------------- +// Purpose: Functions for displaying HTML pages and interacting with them +//----------------------------------------------------------------------------- +class ISteamHTMLSurface +{ +public: + virtual ~ISteamHTMLSurface() {} + + // Must call init and shutdown when starting/ending use of the interface + virtual bool Init() = 0; + virtual bool Shutdown() = 0; + + // Create a browser object for display of a html page, when creation is complete the call handle + // will return a HTML_BrowserReady_t callback for the HHTMLBrowser of your new browser. + // The user agent string is a substring to be added to the general user agent string so you can + // identify your client on web servers. + // The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if + // you do not require this functionality. + // + // YOU MUST HAVE IMPLEMENTED HANDLERS FOR HTML_BrowserReady_t, HTML_StartRequest_t, + // HTML_JSAlert_t, HTML_JSConfirm_t, and HTML_FileOpenDialog_t! See the CALLBACKS + // section of this interface (AllowStartRequest, etc) for more details. If you do + // not implement these callback handlers, the browser may appear to hang instead of + // navigating to new pages or triggering javascript popups. + // + STEAM_CALL_RESULT( HTML_BrowserReady_t ) + virtual SteamAPICall_t CreateBrowser( const char *pchUserAgent, const char *pchUserCSS ) = 0; + + // Call this when you are done with a html surface, this lets us free the resources being used by it + virtual void RemoveBrowser( HHTMLBrowser unBrowserHandle ) = 0; + + // Navigate to this URL, results in a HTML_StartRequest_t as the request commences + virtual void LoadURL( HHTMLBrowser unBrowserHandle, const char *pchURL, const char *pchPostData ) = 0; + + // Tells the surface the size in pixels to display the surface + virtual void SetSize( HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight ) = 0; + + // Stop the load of the current html page + virtual void StopLoad( HHTMLBrowser unBrowserHandle ) = 0; + // Reload (most likely from local cache) the current page + virtual void Reload( HHTMLBrowser unBrowserHandle ) = 0; + // navigate back in the page history + virtual void GoBack( HHTMLBrowser unBrowserHandle ) = 0; + // navigate forward in the page history + virtual void GoForward( HHTMLBrowser unBrowserHandle ) = 0; + + // add this header to any url requests from this browser + virtual void AddHeader( HHTMLBrowser unBrowserHandle, const char *pchKey, const char *pchValue ) = 0; + // run this javascript script in the currently loaded page + virtual void ExecuteJavascript( HHTMLBrowser unBrowserHandle, const char *pchScript ) = 0; + + enum EHTMLMouseButton + { + eHTMLMouseButton_Left = 0, + eHTMLMouseButton_Right = 1, + eHTMLMouseButton_Middle = 2, + }; + + // Mouse click and mouse movement commands + virtual void MouseUp( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; + virtual void MouseDown( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; + virtual void MouseDoubleClick( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; + // x and y are relative to the HTML bounds + virtual void MouseMove( HHTMLBrowser unBrowserHandle, int x, int y ) = 0; + // nDelta is pixels of scroll + virtual void MouseWheel( HHTMLBrowser unBrowserHandle, int32 nDelta ) = 0; + + enum EMouseCursor + { + dc_user = 0, + dc_none, + dc_arrow, + dc_ibeam, + dc_hourglass, + dc_waitarrow, + dc_crosshair, + dc_up, + dc_sizenw, + dc_sizese, + dc_sizene, + dc_sizesw, + dc_sizew, + dc_sizee, + dc_sizen, + dc_sizes, + dc_sizewe, + dc_sizens, + dc_sizeall, + dc_no, + dc_hand, + dc_blank, // don't show any custom cursor, just use your default + dc_middle_pan, + dc_north_pan, + dc_north_east_pan, + dc_east_pan, + dc_south_east_pan, + dc_south_pan, + dc_south_west_pan, + dc_west_pan, + dc_north_west_pan, + dc_alias, + dc_cell, + dc_colresize, + dc_copycur, + dc_verticaltext, + dc_rowresize, + dc_zoomin, + dc_zoomout, + dc_help, + dc_custom, + + dc_last, // custom cursors start from this value and up + }; + + enum EHTMLKeyModifiers + { + k_eHTMLKeyModifier_None = 0, + k_eHTMLKeyModifier_AltDown = 1 << 0, + k_eHTMLKeyModifier_CtrlDown = 1 << 1, + k_eHTMLKeyModifier_ShiftDown = 1 << 2, + }; + + // keyboard interactions, native keycode is the virtual key code value from your OS, system key flags the key to not + // be sent as a typed character as well as a key down + virtual void KeyDown( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers, bool bIsSystemKey = false ) = 0; + virtual void KeyUp( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0; + // cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press) + virtual void KeyChar( HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0; + + // programmatically scroll this many pixels on the page + virtual void SetHorizontalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0; + virtual void SetVerticalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0; + + // tell the html control if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things + virtual void SetKeyFocus( HHTMLBrowser unBrowserHandle, bool bHasKeyFocus ) = 0; + + // open the current pages html code in the local editor of choice, used for debugging + virtual void ViewSource( HHTMLBrowser unBrowserHandle ) = 0; + // copy the currently selected text on the html page to the local clipboard + virtual void CopyToClipboard( HHTMLBrowser unBrowserHandle ) = 0; + // paste from the local clipboard to the current html page + virtual void PasteFromClipboard( HHTMLBrowser unBrowserHandle ) = 0; + + // find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element + virtual void Find( HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse ) = 0; + // cancel a currently running find + virtual void StopFind( HHTMLBrowser unBrowserHandle ) = 0; + + // return details about the link at position x,y on the current page + virtual void GetLinkAtPosition( HHTMLBrowser unBrowserHandle, int x, int y ) = 0; + + // set a webcookie for the hostname in question + virtual void SetCookie( const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath = "/", RTime32 nExpires = 0, bool bSecure = false, bool bHTTPOnly = false ) = 0; + + // Zoom the current page by flZoom ( from 0.0 to 2.0, so to zoom to 120% use 1.2 ), zooming around point X,Y in the page (use 0,0 if you don't care) + virtual void SetPageScaleFactor( HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY ) = 0; + + // Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are + // more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled, + // all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1". + // When background mode is disabled, any video or audio objects with that property will resume with ".play()". + virtual void SetBackgroundMode( HHTMLBrowser unBrowserHandle, bool bBackgroundMode ) = 0; + + // Scale the output display space by this factor, this is useful when displaying content on high dpi devices. + // Specifies the ratio between physical and logical pixels. + virtual void SetDPIScalingFactor( HHTMLBrowser unBrowserHandle, float flDPIScaling ) = 0; + + // Open HTML/JS developer tools + virtual void OpenDeveloperTools( HHTMLBrowser unBrowserHandle ) = 0; + + // CALLBACKS + // + // These set of functions are used as responses to callback requests + // + + // You MUST call this in response to a HTML_StartRequest_t callback + // Set bAllowed to true to allow this navigation, false to cancel it and stay + // on the current page. You can use this feature to limit the valid pages + // allowed in your HTML surface. + virtual void AllowStartRequest( HHTMLBrowser unBrowserHandle, bool bAllowed ) = 0; + + // You MUST call this in response to a HTML_JSAlert_t or HTML_JSConfirm_t callback + // Set bResult to true for the OK option of a confirm, use false otherwise + virtual void JSDialogResponse( HHTMLBrowser unBrowserHandle, bool bResult ) = 0; + + // You MUST call this in response to a HTML_FileOpenDialog_t callback + virtual void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles ) = 0; +}; + +#define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_005" + +// Global interface accessor +inline ISteamHTMLSurface *SteamHTMLSurface(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTMLSurface *, SteamHTMLSurface, STEAMHTMLSURFACE_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +//----------------------------------------------------------------------------- +// Purpose: The browser is ready for use +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_BrowserReady_t, k_iSteamHTMLSurfaceCallbacks + 1 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // this browser is now fully created and ready to navigate to pages +STEAM_CALLBACK_END(1) + + +//----------------------------------------------------------------------------- +// Purpose: the browser has a pending paint +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN(HTML_NeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 2) +STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the browser that needs the paint +STEAM_CALLBACK_MEMBER(1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called +STEAM_CALLBACK_MEMBER(2, uint32, unWide) // the total width of the pBGRA texture +STEAM_CALLBACK_MEMBER(3, uint32, unTall) // the total height of the pBGRA texture +STEAM_CALLBACK_MEMBER(4, uint32, unUpdateX) // the offset in X for the damage rect for this update +STEAM_CALLBACK_MEMBER(5, uint32, unUpdateY) // the offset in Y for the damage rect for this update +STEAM_CALLBACK_MEMBER(6, uint32, unUpdateWide) // the width of the damage rect for this update +STEAM_CALLBACK_MEMBER(7, uint32, unUpdateTall) // the height of the damage rect for this update +STEAM_CALLBACK_MEMBER(8, uint32, unScrollX) // the page scroll the browser was at when this texture was rendered +STEAM_CALLBACK_MEMBER(9, uint32, unScrollY) // the page scroll the browser was at when this texture was rendered +STEAM_CALLBACK_MEMBER(10, float, flPageScale) // the page scale factor on this page when rendered +STEAM_CALLBACK_MEMBER(11, uint32, unPageSerial) // incremented on each new page load, you can use this to reject draws while navigating to new pages +STEAM_CALLBACK_END(12) + + +//----------------------------------------------------------------------------- +// Purpose: The browser wanted to navigate to a new page +// NOTE - you MUST call AllowStartRequest in response to this callback +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN(HTML_StartRequest_t, k_iSteamHTMLSurfaceCallbacks + 3) +STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface navigating +STEAM_CALLBACK_MEMBER(1, const char *, pchURL) // the url they wish to navigate to +STEAM_CALLBACK_MEMBER(2, const char *, pchTarget) // the html link target type (i.e _blank, _self, _parent, _top ) +STEAM_CALLBACK_MEMBER(3, const char *, pchPostData ) // any posted data for the request +STEAM_CALLBACK_MEMBER(4, bool, bIsRedirect) // true if this was a http/html redirect from the last load request +STEAM_CALLBACK_END(5) + + +//----------------------------------------------------------------------------- +// Purpose: The browser has been requested to close due to user interaction (usually from a javascript window.close() call) +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN(HTML_CloseBrowser_t, k_iSteamHTMLSurfaceCallbacks + 4) +STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface +STEAM_CALLBACK_END(1) + + +//----------------------------------------------------------------------------- +// Purpose: the browser is navigating to a new url +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_URLChanged_t, k_iSteamHTMLSurfaceCallbacks + 5 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface navigating +STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // the url they wish to navigate to +STEAM_CALLBACK_MEMBER( 2, const char *, pchPostData ) // any posted data for the request +STEAM_CALLBACK_MEMBER( 3, bool, bIsRedirect ) // true if this was a http/html redirect from the last load request +STEAM_CALLBACK_MEMBER( 4, const char *, pchPageTitle ) // the title of the page +STEAM_CALLBACK_MEMBER( 5, bool, bNewNavigation ) // true if this was from a fresh tab and not a click on an existing page +STEAM_CALLBACK_END(6) + + +//----------------------------------------------------------------------------- +// Purpose: A page is finished loading +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_FinishedRequest_t, k_iSteamHTMLSurfaceCallbacks + 6 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // +STEAM_CALLBACK_MEMBER( 2, const char *, pchPageTitle ) // +STEAM_CALLBACK_END(3) + + +//----------------------------------------------------------------------------- +// Purpose: a request to load this url in a new tab +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_OpenLinkInNewTab_t, k_iSteamHTMLSurfaceCallbacks + 7 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: the page has a new title now +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_ChangedTitle_t, k_iSteamHTMLSurfaceCallbacks + 8 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) // +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: results from a search +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_SearchResults_t, k_iSteamHTMLSurfaceCallbacks + 9 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, uint32, unResults ) // +STEAM_CALLBACK_MEMBER( 2, uint32, unCurrentMatch ) // +STEAM_CALLBACK_END(3) + + +//----------------------------------------------------------------------------- +// Purpose: page history status changed on the ability to go backwards and forward +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_CanGoBackAndForward_t, k_iSteamHTMLSurfaceCallbacks + 10 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, bool, bCanGoBack ) // +STEAM_CALLBACK_MEMBER( 2, bool, bCanGoForward ) // +STEAM_CALLBACK_END(3) + + +//----------------------------------------------------------------------------- +// Purpose: details on the visibility and size of the horizontal scrollbar +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_HorizontalScroll_t, k_iSteamHTMLSurfaceCallbacks + 11 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) // +STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) // +STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) // +STEAM_CALLBACK_MEMBER( 4, bool , bVisible ) // +STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) // +STEAM_CALLBACK_END(6) + + +//----------------------------------------------------------------------------- +// Purpose: details on the visibility and size of the vertical scrollbar +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_VerticalScroll_t, k_iSteamHTMLSurfaceCallbacks + 12 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) // +STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) // +STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) // +STEAM_CALLBACK_MEMBER( 4, bool, bVisible ) // +STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) // +STEAM_CALLBACK_END(6) + + +//----------------------------------------------------------------------------- +// Purpose: response to GetLinkAtPosition call +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_LinkAtPosition_t, k_iSteamHTMLSurfaceCallbacks + 13 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, uint32, x ) // NOTE - Not currently set +STEAM_CALLBACK_MEMBER( 2, uint32, y ) // NOTE - Not currently set +STEAM_CALLBACK_MEMBER( 3, const char *, pchURL ) // +STEAM_CALLBACK_MEMBER( 4, bool, bInput ) // +STEAM_CALLBACK_MEMBER( 5, bool, bLiveLink ) // +STEAM_CALLBACK_END(6) + + + +//----------------------------------------------------------------------------- +// Purpose: show a Javascript alert dialog, call JSDialogResponse +// when the user dismisses this dialog (or right away to ignore it) +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_JSAlert_t, k_iSteamHTMLSurfaceCallbacks + 14 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) // +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: show a Javascript confirmation dialog, call JSDialogResponse +// when the user dismisses this dialog (or right away to ignore it) +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_JSConfirm_t, k_iSteamHTMLSurfaceCallbacks + 15 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) // +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: when received show a file open dialog +// then call FileLoadDialogResponse with the file(s) the user selected. +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_FileOpenDialog_t, k_iSteamHTMLSurfaceCallbacks + 16 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) // +STEAM_CALLBACK_MEMBER( 2, const char *, pchInitialFile ) // +STEAM_CALLBACK_END(3) + + +//----------------------------------------------------------------------------- +// Purpose: a new html window is being created. +// +// IMPORTANT NOTE: at this time, the API does not allow you to acknowledge or +// render the contents of this new window, so the new window is always destroyed +// immediately. The URL and other parameters of the new window are passed here +// to give your application the opportunity to call CreateBrowser and set up +// a new browser in response to the attempted popup, if you wish to do so. +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_NewWindow_t, k_iSteamHTMLSurfaceCallbacks + 21 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the current surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // the page to load +STEAM_CALLBACK_MEMBER( 2, uint32, unX ) // the x pos into the page to display the popup +STEAM_CALLBACK_MEMBER( 3, uint32, unY ) // the y pos into the page to display the popup +STEAM_CALLBACK_MEMBER( 4, uint32, unWide ) // the total width of the pBGRA texture +STEAM_CALLBACK_MEMBER( 5, uint32, unTall ) // the total height of the pBGRA texture +STEAM_CALLBACK_MEMBER( 6, HHTMLBrowser, unNewWindow_BrowserHandle_IGNORE ) +STEAM_CALLBACK_END(7) + + +//----------------------------------------------------------------------------- +// Purpose: change the cursor to display +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_SetCursor_t, k_iSteamHTMLSurfaceCallbacks + 22 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EMouseCursor to display +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: informational message from the browser +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_StatusText_t, k_iSteamHTMLSurfaceCallbacks + 23 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: show a tooltip +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_ShowToolTip_t, k_iSteamHTMLSurfaceCallbacks + 24 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: update the text of an existing tooltip +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_UpdateToolTip_t, k_iSteamHTMLSurfaceCallbacks + 25 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display +STEAM_CALLBACK_END(2) + + +//----------------------------------------------------------------------------- +// Purpose: hide the tooltip you are showing +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_HideToolTip_t, k_iSteamHTMLSurfaceCallbacks + 26 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface +STEAM_CALLBACK_END(1) + + +//----------------------------------------------------------------------------- +// Purpose: The browser has restarted due to an internal failure, use this new handle value +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( HTML_BrowserRestarted_t, k_iSteamHTMLSurfaceCallbacks + 27 ) +STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // this is the new browser handle after the restart +STEAM_CALLBACK_MEMBER( 1, HHTMLBrowser, unOldBrowserHandle ) // the handle for the browser before the restart, if your handle was this then switch to using unBrowserHandle for API calls +STEAM_CALLBACK_END(2) + + +#pragma pack( pop ) + + +#endif // ISTEAMHTMLSURFACE_H diff --git a/lsteamclient/steamworks_sdk_160/isteamhttp.h b/lsteamclient/steamworks_sdk_160/isteamhttp.h new file mode 100644 index 0000000000..fb034ca1dc --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamhttp.h @@ -0,0 +1,219 @@ +//====== Copyright © 1996-2009, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to http client +// +//============================================================================= + +#ifndef ISTEAMHTTP_H +#define ISTEAMHTTP_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "steamhttpenums.h" + +// Handle to a HTTP Request handle +typedef uint32 HTTPRequestHandle; +#define INVALID_HTTPREQUEST_HANDLE 0 + +typedef uint32 HTTPCookieContainerHandle; +#define INVALID_HTTPCOOKIE_HANDLE 0 + +//----------------------------------------------------------------------------- +// Purpose: interface to http client +//----------------------------------------------------------------------------- +class ISteamHTTP +{ +public: + + // Initializes a new HTTP request, returning a handle to use in further operations on it. Requires + // the method (GET or POST) and the absolute URL for the request. Both http and https are supported, + // so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/ + // or such. + virtual HTTPRequestHandle CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL ) = 0; + + // Set a context value for the request, which will be returned in the HTTPRequestCompleted_t callback after + // sending the request. This is just so the caller can easily keep track of which callbacks go with which request data. + virtual bool SetHTTPRequestContextValue( HTTPRequestHandle hRequest, uint64 ulContextValue ) = 0; + + // Set a timeout in seconds for the HTTP request, must be called prior to sending the request. Default + // timeout is 60 seconds if you don't call this. Returns false if the handle is invalid, or the request + // has already been sent. + virtual bool SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint32 unTimeoutSeconds ) = 0; + + // Set a request header value for the request, must be called prior to sending the request. Will + // return false if the handle is invalid or the request is already sent. + virtual bool SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue ) = 0; + + // Set a GET or POST parameter value on the request, which is set will depend on the EHTTPMethod specified + // when creating the request. Must be called prior to sending the request. Will return false if the + // handle is invalid or the request is already sent. + virtual bool SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue ) = 0; + + // Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on + // asynchronous response via callback. + // + // Note: If the user is in offline mode in Steam, then this will add a only-if-cached cache-control + // header and only do a local cache lookup rather than sending any actual remote request. + virtual bool SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0; + + // Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on + // asynchronous response via callback for completion, and listen for HTTPRequestHeadersReceived_t and + // HTTPRequestDataReceived_t callbacks while streaming. + virtual bool SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0; + + // Defers a request you have sent, the actual HTTP client code may have many requests queued, and this will move + // the specified request to the tail of the queue. Returns false on invalid handle, or if the request is not yet sent. + virtual bool DeferHTTPRequest( HTTPRequestHandle hRequest ) = 0; + + // Prioritizes a request you have sent, the actual HTTP client code may have many requests queued, and this will move + // the specified request to the head of the queue. Returns false on invalid handle, or if the request is not yet sent. + virtual bool PrioritizeHTTPRequest( HTTPRequestHandle hRequest ) = 0; + + // Checks if a response header is present in a HTTP response given a handle from HTTPRequestCompleted_t, also + // returns the size of the header value if present so the caller and allocate a correctly sized buffer for + // GetHTTPResponseHeaderValue. + virtual bool GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize ) = 0; + + // Gets header values from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the + // header is not present or if your buffer is too small to contain it's value. You should first call + // BGetHTTPResponseHeaderSize to check for the presence of the header and to find out the size buffer needed. + virtual bool GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize ) = 0; + + // Gets the size of the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the + // handle is invalid. + virtual bool GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *unBodySize ) = 0; + + // Gets the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the + // handle is invalid or is to a streaming response, or if the provided buffer is not the correct size. Use BGetHTTPResponseBodySize first to find out + // the correct buffer size to use. + virtual bool GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0; + + // Gets the body data from a streaming HTTP response given a handle from HTTPRequestDataReceived_t. Will return false if the + // handle is invalid or is to a non-streaming response (meaning it wasn't sent with SendHTTPRequestAndStreamResponse), or if the buffer size and offset + // do not match the size and offset sent in HTTPRequestDataReceived_t. + virtual bool GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0; + + // Releases an HTTP response handle, should always be called to free resources after receiving a HTTPRequestCompleted_t + // callback and finishing using the response. + virtual bool ReleaseHTTPRequest( HTTPRequestHandle hRequest ) = 0; + + // Gets progress on downloading the body for the request. This will be zero unless a response header has already been + // received which included a content-length field. For responses that contain no content-length it will report + // zero for the duration of the request as the size is unknown until the connection closes. + virtual bool GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *pflPercentOut ) = 0; + + // Sets the body for an HTTP Post request. Will fail and return false on a GET request, and will fail if POST params + // have already been set for the request. Setting this raw body makes it the only contents for the post, the pchContentType + // parameter will set the content-type header for the request so the server may know how to interpret the body. + virtual bool SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen ) = 0; + + // Creates a cookie container handle which you must later free with ReleaseCookieContainer(). If bAllowResponsesToModify=true + // than any response to your requests using this cookie container may add new cookies which may be transmitted with + // future requests. If bAllowResponsesToModify=false than only cookies you explicitly set will be sent. This API is just for + // during process lifetime, after steam restarts no cookies are persisted and you have no way to access the cookie container across + // repeat executions of your process. + virtual HTTPCookieContainerHandle CreateCookieContainer( bool bAllowResponsesToModify ) = 0; + + // Release a cookie container you are finished using, freeing it's memory + virtual bool ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) = 0; + + // Adds a cookie to the specified cookie container that will be used with future requests. + virtual bool SetCookie( HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie ) = 0; + + // Set the cookie container to use for a HTTP request + virtual bool SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ) = 0; + + // Set the extra user agent info for a request, this doesn't clobber the normal user agent, it just adds the extra info on the end + virtual bool SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const char *pchUserAgentInfo ) = 0; + + // Disable or re-enable verification of SSL/TLS certificates. + // By default, certificates are checked for all HTTPS requests. + virtual bool SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate ) = 0; + + // Set an absolute timeout on the HTTP request, this is just a total time timeout different than the network activity timeout + // which can bump everytime we get more data + virtual bool SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint32 unMilliseconds ) = 0; + + // Check if the reason the request failed was because we timed it out (rather than some harder failure) + virtual bool GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, bool *pbWasTimedOut ) = 0; +}; + +#define STEAMHTTP_INTERFACE_VERSION "STEAMHTTP_INTERFACE_VERSION003" + +// Global interface accessor +inline ISteamHTTP *SteamHTTP(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamHTTP, STEAMHTTP_INTERFACE_VERSION ); + +// Global accessor for the gameserver client +inline ISteamHTTP *SteamGameServerHTTP(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamGameServerHTTP, STEAMHTTP_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +struct HTTPRequestCompleted_t +{ + enum { k_iCallback = k_iSteamHTTPCallbacks + 1 }; + + // Handle value for the request that has completed. + HTTPRequestHandle m_hRequest; + + // Context value that the user defined on the request that this callback is associated with, 0 if + // no context value was set. + uint64 m_ulContextValue; + + // This will be true if we actually got any sort of response from the server (even an error). + // It will be false if we failed due to an internal error or client side network failure. + bool m_bRequestSuccessful; + + // Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal + // OK response, if you get something else you probably need to treat it as a failure. + EHTTPStatusCode m_eStatusCode; + + uint32 m_unBodySize; // Same as GetHTTPResponseBodySize() +}; + + +struct HTTPRequestHeadersReceived_t +{ + enum { k_iCallback = k_iSteamHTTPCallbacks + 2 }; + + // Handle value for the request that has received headers. + HTTPRequestHandle m_hRequest; + + // Context value that the user defined on the request that this callback is associated with, 0 if + // no context value was set. + uint64 m_ulContextValue; +}; + +struct HTTPRequestDataReceived_t +{ + enum { k_iCallback = k_iSteamHTTPCallbacks + 3 }; + + // Handle value for the request that has received data. + HTTPRequestHandle m_hRequest; + + // Context value that the user defined on the request that this callback is associated with, 0 if + // no context value was set. + uint64 m_ulContextValue; + + + // Offset to provide to GetHTTPStreamingResponseBodyData to get this chunk of data + uint32 m_cOffset; + + // Size to provide to GetHTTPStreamingResponseBodyData to get this chunk of data + uint32 m_cBytesReceived; +}; + + +#pragma pack( pop ) + +#endif // ISTEAMHTTP_H \ No newline at end of file diff --git a/lsteamclient/steamworks_sdk_160/isteaminput.h b/lsteamclient/steamworks_sdk_160/isteaminput.h new file mode 100644 index 0000000000..f3fea1304e --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteaminput.h @@ -0,0 +1,982 @@ +//====== Copyright 1996-2018, Valve Corporation, All rights reserved. ======= +// +// Purpose: Steam Input is a flexible input API that supports over three hundred devices including all +// common variants of Xbox, Playstation, Nintendo Switch Pro, and Steam Controllers. +// For more info including a getting started guide for developers +// please visit: https://partner.steamgames.com/doc/features/steam_controller +// +//============================================================================= + +#ifndef ISTEAMINPUT_H +#define ISTEAMINPUT_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +#define STEAM_INPUT_MAX_COUNT 16 + +#define STEAM_INPUT_MAX_ANALOG_ACTIONS 24 + +#define STEAM_INPUT_MAX_DIGITAL_ACTIONS 256 + +#define STEAM_INPUT_MAX_ORIGINS 8 + +#define STEAM_INPUT_MAX_ACTIVE_LAYERS 16 + +// When sending an option to a specific controller handle, you can send to all devices via this command +#define STEAM_INPUT_HANDLE_ALL_CONTROLLERS UINT64_MAX + +#define STEAM_INPUT_MIN_ANALOG_ACTION_DATA -1.0f +#define STEAM_INPUT_MAX_ANALOG_ACTION_DATA 1.0f + +enum EInputSourceMode +{ + k_EInputSourceMode_None, + k_EInputSourceMode_Dpad, + k_EInputSourceMode_Buttons, + k_EInputSourceMode_FourButtons, + k_EInputSourceMode_AbsoluteMouse, + k_EInputSourceMode_RelativeMouse, + k_EInputSourceMode_JoystickMove, + k_EInputSourceMode_JoystickMouse, + k_EInputSourceMode_JoystickCamera, + k_EInputSourceMode_ScrollWheel, + k_EInputSourceMode_Trigger, + k_EInputSourceMode_TouchMenu, + k_EInputSourceMode_MouseJoystick, + k_EInputSourceMode_MouseRegion, + k_EInputSourceMode_RadialMenu, + k_EInputSourceMode_SingleButton, + k_EInputSourceMode_Switches +}; + +// Note: Please do not use action origins as a way to identify controller types. There is no +// guarantee that they will be added in a contiguous manner - use GetInputTypeForHandle instead. +// Versions of Steam that add new controller types in the future will extend this enum so if you're +// using a lookup table please check the bounds of any origins returned by Steam. +enum EInputActionOrigin +{ + // Steam Controller + k_EInputActionOrigin_None, + k_EInputActionOrigin_SteamController_A, + k_EInputActionOrigin_SteamController_B, + k_EInputActionOrigin_SteamController_X, + k_EInputActionOrigin_SteamController_Y, + k_EInputActionOrigin_SteamController_LeftBumper, + k_EInputActionOrigin_SteamController_RightBumper, + k_EInputActionOrigin_SteamController_LeftGrip, + k_EInputActionOrigin_SteamController_RightGrip, + k_EInputActionOrigin_SteamController_Start, + k_EInputActionOrigin_SteamController_Back, + k_EInputActionOrigin_SteamController_LeftPad_Touch, + k_EInputActionOrigin_SteamController_LeftPad_Swipe, + k_EInputActionOrigin_SteamController_LeftPad_Click, + k_EInputActionOrigin_SteamController_LeftPad_DPadNorth, + k_EInputActionOrigin_SteamController_LeftPad_DPadSouth, + k_EInputActionOrigin_SteamController_LeftPad_DPadWest, + k_EInputActionOrigin_SteamController_LeftPad_DPadEast, + k_EInputActionOrigin_SteamController_RightPad_Touch, + k_EInputActionOrigin_SteamController_RightPad_Swipe, + k_EInputActionOrigin_SteamController_RightPad_Click, + k_EInputActionOrigin_SteamController_RightPad_DPadNorth, + k_EInputActionOrigin_SteamController_RightPad_DPadSouth, + k_EInputActionOrigin_SteamController_RightPad_DPadWest, + k_EInputActionOrigin_SteamController_RightPad_DPadEast, + k_EInputActionOrigin_SteamController_LeftTrigger_Pull, + k_EInputActionOrigin_SteamController_LeftTrigger_Click, + k_EInputActionOrigin_SteamController_RightTrigger_Pull, + k_EInputActionOrigin_SteamController_RightTrigger_Click, + k_EInputActionOrigin_SteamController_LeftStick_Move, + k_EInputActionOrigin_SteamController_LeftStick_Click, + k_EInputActionOrigin_SteamController_LeftStick_DPadNorth, + k_EInputActionOrigin_SteamController_LeftStick_DPadSouth, + k_EInputActionOrigin_SteamController_LeftStick_DPadWest, + k_EInputActionOrigin_SteamController_LeftStick_DPadEast, + k_EInputActionOrigin_SteamController_Gyro_Move, + k_EInputActionOrigin_SteamController_Gyro_Pitch, + k_EInputActionOrigin_SteamController_Gyro_Yaw, + k_EInputActionOrigin_SteamController_Gyro_Roll, + k_EInputActionOrigin_SteamController_Reserved0, + k_EInputActionOrigin_SteamController_Reserved1, + k_EInputActionOrigin_SteamController_Reserved2, + k_EInputActionOrigin_SteamController_Reserved3, + k_EInputActionOrigin_SteamController_Reserved4, + k_EInputActionOrigin_SteamController_Reserved5, + k_EInputActionOrigin_SteamController_Reserved6, + k_EInputActionOrigin_SteamController_Reserved7, + k_EInputActionOrigin_SteamController_Reserved8, + k_EInputActionOrigin_SteamController_Reserved9, + k_EInputActionOrigin_SteamController_Reserved10, + + // PS4 Dual Shock + k_EInputActionOrigin_PS4_X, + k_EInputActionOrigin_PS4_Circle, + k_EInputActionOrigin_PS4_Triangle, + k_EInputActionOrigin_PS4_Square, + k_EInputActionOrigin_PS4_LeftBumper, + k_EInputActionOrigin_PS4_RightBumper, + k_EInputActionOrigin_PS4_Options, //Start + k_EInputActionOrigin_PS4_Share, //Back + k_EInputActionOrigin_PS4_LeftPad_Touch, + k_EInputActionOrigin_PS4_LeftPad_Swipe, + k_EInputActionOrigin_PS4_LeftPad_Click, + k_EInputActionOrigin_PS4_LeftPad_DPadNorth, + k_EInputActionOrigin_PS4_LeftPad_DPadSouth, + k_EInputActionOrigin_PS4_LeftPad_DPadWest, + k_EInputActionOrigin_PS4_LeftPad_DPadEast, + k_EInputActionOrigin_PS4_RightPad_Touch, + k_EInputActionOrigin_PS4_RightPad_Swipe, + k_EInputActionOrigin_PS4_RightPad_Click, + k_EInputActionOrigin_PS4_RightPad_DPadNorth, + k_EInputActionOrigin_PS4_RightPad_DPadSouth, + k_EInputActionOrigin_PS4_RightPad_DPadWest, + k_EInputActionOrigin_PS4_RightPad_DPadEast, + k_EInputActionOrigin_PS4_CenterPad_Touch, + k_EInputActionOrigin_PS4_CenterPad_Swipe, + k_EInputActionOrigin_PS4_CenterPad_Click, + k_EInputActionOrigin_PS4_CenterPad_DPadNorth, + k_EInputActionOrigin_PS4_CenterPad_DPadSouth, + k_EInputActionOrigin_PS4_CenterPad_DPadWest, + k_EInputActionOrigin_PS4_CenterPad_DPadEast, + k_EInputActionOrigin_PS4_LeftTrigger_Pull, + k_EInputActionOrigin_PS4_LeftTrigger_Click, + k_EInputActionOrigin_PS4_RightTrigger_Pull, + k_EInputActionOrigin_PS4_RightTrigger_Click, + k_EInputActionOrigin_PS4_LeftStick_Move, + k_EInputActionOrigin_PS4_LeftStick_Click, + k_EInputActionOrigin_PS4_LeftStick_DPadNorth, + k_EInputActionOrigin_PS4_LeftStick_DPadSouth, + k_EInputActionOrigin_PS4_LeftStick_DPadWest, + k_EInputActionOrigin_PS4_LeftStick_DPadEast, + k_EInputActionOrigin_PS4_RightStick_Move, + k_EInputActionOrigin_PS4_RightStick_Click, + k_EInputActionOrigin_PS4_RightStick_DPadNorth, + k_EInputActionOrigin_PS4_RightStick_DPadSouth, + k_EInputActionOrigin_PS4_RightStick_DPadWest, + k_EInputActionOrigin_PS4_RightStick_DPadEast, + k_EInputActionOrigin_PS4_DPad_North, + k_EInputActionOrigin_PS4_DPad_South, + k_EInputActionOrigin_PS4_DPad_West, + k_EInputActionOrigin_PS4_DPad_East, + k_EInputActionOrigin_PS4_Gyro_Move, + k_EInputActionOrigin_PS4_Gyro_Pitch, + k_EInputActionOrigin_PS4_Gyro_Yaw, + k_EInputActionOrigin_PS4_Gyro_Roll, + k_EInputActionOrigin_PS4_DPad_Move, + k_EInputActionOrigin_PS4_Reserved1, + k_EInputActionOrigin_PS4_Reserved2, + k_EInputActionOrigin_PS4_Reserved3, + k_EInputActionOrigin_PS4_Reserved4, + k_EInputActionOrigin_PS4_Reserved5, + k_EInputActionOrigin_PS4_Reserved6, + k_EInputActionOrigin_PS4_Reserved7, + k_EInputActionOrigin_PS4_Reserved8, + k_EInputActionOrigin_PS4_Reserved9, + k_EInputActionOrigin_PS4_Reserved10, + + // XBox One + k_EInputActionOrigin_XBoxOne_A, + k_EInputActionOrigin_XBoxOne_B, + k_EInputActionOrigin_XBoxOne_X, + k_EInputActionOrigin_XBoxOne_Y, + k_EInputActionOrigin_XBoxOne_LeftBumper, + k_EInputActionOrigin_XBoxOne_RightBumper, + k_EInputActionOrigin_XBoxOne_Menu, //Start + k_EInputActionOrigin_XBoxOne_View, //Back + k_EInputActionOrigin_XBoxOne_LeftTrigger_Pull, + k_EInputActionOrigin_XBoxOne_LeftTrigger_Click, + k_EInputActionOrigin_XBoxOne_RightTrigger_Pull, + k_EInputActionOrigin_XBoxOne_RightTrigger_Click, + k_EInputActionOrigin_XBoxOne_LeftStick_Move, + k_EInputActionOrigin_XBoxOne_LeftStick_Click, + k_EInputActionOrigin_XBoxOne_LeftStick_DPadNorth, + k_EInputActionOrigin_XBoxOne_LeftStick_DPadSouth, + k_EInputActionOrigin_XBoxOne_LeftStick_DPadWest, + k_EInputActionOrigin_XBoxOne_LeftStick_DPadEast, + k_EInputActionOrigin_XBoxOne_RightStick_Move, + k_EInputActionOrigin_XBoxOne_RightStick_Click, + k_EInputActionOrigin_XBoxOne_RightStick_DPadNorth, + k_EInputActionOrigin_XBoxOne_RightStick_DPadSouth, + k_EInputActionOrigin_XBoxOne_RightStick_DPadWest, + k_EInputActionOrigin_XBoxOne_RightStick_DPadEast, + k_EInputActionOrigin_XBoxOne_DPad_North, + k_EInputActionOrigin_XBoxOne_DPad_South, + k_EInputActionOrigin_XBoxOne_DPad_West, + k_EInputActionOrigin_XBoxOne_DPad_East, + k_EInputActionOrigin_XBoxOne_DPad_Move, + k_EInputActionOrigin_XBoxOne_LeftGrip_Lower, + k_EInputActionOrigin_XBoxOne_LeftGrip_Upper, + k_EInputActionOrigin_XBoxOne_RightGrip_Lower, + k_EInputActionOrigin_XBoxOne_RightGrip_Upper, + k_EInputActionOrigin_XBoxOne_Share, // Xbox Series X controllers only + k_EInputActionOrigin_XBoxOne_Reserved6, + k_EInputActionOrigin_XBoxOne_Reserved7, + k_EInputActionOrigin_XBoxOne_Reserved8, + k_EInputActionOrigin_XBoxOne_Reserved9, + k_EInputActionOrigin_XBoxOne_Reserved10, + + // XBox 360 + k_EInputActionOrigin_XBox360_A, + k_EInputActionOrigin_XBox360_B, + k_EInputActionOrigin_XBox360_X, + k_EInputActionOrigin_XBox360_Y, + k_EInputActionOrigin_XBox360_LeftBumper, + k_EInputActionOrigin_XBox360_RightBumper, + k_EInputActionOrigin_XBox360_Start, //Start + k_EInputActionOrigin_XBox360_Back, //Back + k_EInputActionOrigin_XBox360_LeftTrigger_Pull, + k_EInputActionOrigin_XBox360_LeftTrigger_Click, + k_EInputActionOrigin_XBox360_RightTrigger_Pull, + k_EInputActionOrigin_XBox360_RightTrigger_Click, + k_EInputActionOrigin_XBox360_LeftStick_Move, + k_EInputActionOrigin_XBox360_LeftStick_Click, + k_EInputActionOrigin_XBox360_LeftStick_DPadNorth, + k_EInputActionOrigin_XBox360_LeftStick_DPadSouth, + k_EInputActionOrigin_XBox360_LeftStick_DPadWest, + k_EInputActionOrigin_XBox360_LeftStick_DPadEast, + k_EInputActionOrigin_XBox360_RightStick_Move, + k_EInputActionOrigin_XBox360_RightStick_Click, + k_EInputActionOrigin_XBox360_RightStick_DPadNorth, + k_EInputActionOrigin_XBox360_RightStick_DPadSouth, + k_EInputActionOrigin_XBox360_RightStick_DPadWest, + k_EInputActionOrigin_XBox360_RightStick_DPadEast, + k_EInputActionOrigin_XBox360_DPad_North, + k_EInputActionOrigin_XBox360_DPad_South, + k_EInputActionOrigin_XBox360_DPad_West, + k_EInputActionOrigin_XBox360_DPad_East, + k_EInputActionOrigin_XBox360_DPad_Move, + k_EInputActionOrigin_XBox360_Reserved1, + k_EInputActionOrigin_XBox360_Reserved2, + k_EInputActionOrigin_XBox360_Reserved3, + k_EInputActionOrigin_XBox360_Reserved4, + k_EInputActionOrigin_XBox360_Reserved5, + k_EInputActionOrigin_XBox360_Reserved6, + k_EInputActionOrigin_XBox360_Reserved7, + k_EInputActionOrigin_XBox360_Reserved8, + k_EInputActionOrigin_XBox360_Reserved9, + k_EInputActionOrigin_XBox360_Reserved10, + + + // Switch - Pro or Joycons used as a single input device. + // This does not apply to a single joycon + k_EInputActionOrigin_Switch_A, + k_EInputActionOrigin_Switch_B, + k_EInputActionOrigin_Switch_X, + k_EInputActionOrigin_Switch_Y, + k_EInputActionOrigin_Switch_LeftBumper, + k_EInputActionOrigin_Switch_RightBumper, + k_EInputActionOrigin_Switch_Plus, //Start + k_EInputActionOrigin_Switch_Minus, //Back + k_EInputActionOrigin_Switch_Capture, + k_EInputActionOrigin_Switch_LeftTrigger_Pull, + k_EInputActionOrigin_Switch_LeftTrigger_Click, + k_EInputActionOrigin_Switch_RightTrigger_Pull, + k_EInputActionOrigin_Switch_RightTrigger_Click, + k_EInputActionOrigin_Switch_LeftStick_Move, + k_EInputActionOrigin_Switch_LeftStick_Click, + k_EInputActionOrigin_Switch_LeftStick_DPadNorth, + k_EInputActionOrigin_Switch_LeftStick_DPadSouth, + k_EInputActionOrigin_Switch_LeftStick_DPadWest, + k_EInputActionOrigin_Switch_LeftStick_DPadEast, + k_EInputActionOrigin_Switch_RightStick_Move, + k_EInputActionOrigin_Switch_RightStick_Click, + k_EInputActionOrigin_Switch_RightStick_DPadNorth, + k_EInputActionOrigin_Switch_RightStick_DPadSouth, + k_EInputActionOrigin_Switch_RightStick_DPadWest, + k_EInputActionOrigin_Switch_RightStick_DPadEast, + k_EInputActionOrigin_Switch_DPad_North, + k_EInputActionOrigin_Switch_DPad_South, + k_EInputActionOrigin_Switch_DPad_West, + k_EInputActionOrigin_Switch_DPad_East, + k_EInputActionOrigin_Switch_ProGyro_Move, // Primary Gyro in Pro Controller, or Right JoyCon + k_EInputActionOrigin_Switch_ProGyro_Pitch, // Primary Gyro in Pro Controller, or Right JoyCon + k_EInputActionOrigin_Switch_ProGyro_Yaw, // Primary Gyro in Pro Controller, or Right JoyCon + k_EInputActionOrigin_Switch_ProGyro_Roll, // Primary Gyro in Pro Controller, or Right JoyCon + k_EInputActionOrigin_Switch_DPad_Move, + k_EInputActionOrigin_Switch_Reserved1, + k_EInputActionOrigin_Switch_Reserved2, + k_EInputActionOrigin_Switch_Reserved3, + k_EInputActionOrigin_Switch_Reserved4, + k_EInputActionOrigin_Switch_Reserved5, + k_EInputActionOrigin_Switch_Reserved6, + k_EInputActionOrigin_Switch_Reserved7, + k_EInputActionOrigin_Switch_Reserved8, + k_EInputActionOrigin_Switch_Reserved9, + k_EInputActionOrigin_Switch_Reserved10, + + // Switch JoyCon Specific + k_EInputActionOrigin_Switch_RightGyro_Move, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EInputActionOrigin_Switch_RightGyro_Pitch, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EInputActionOrigin_Switch_RightGyro_Yaw, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EInputActionOrigin_Switch_RightGyro_Roll, // Right JoyCon Gyro generally should correspond to Pro's single gyro + k_EInputActionOrigin_Switch_LeftGyro_Move, + k_EInputActionOrigin_Switch_LeftGyro_Pitch, + k_EInputActionOrigin_Switch_LeftGyro_Yaw, + k_EInputActionOrigin_Switch_LeftGyro_Roll, + k_EInputActionOrigin_Switch_LeftGrip_Lower, // Left JoyCon SR Button + k_EInputActionOrigin_Switch_LeftGrip_Upper, // Left JoyCon SL Button + k_EInputActionOrigin_Switch_RightGrip_Lower, // Right JoyCon SL Button + k_EInputActionOrigin_Switch_RightGrip_Upper, // Right JoyCon SR Button + k_EInputActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical + k_EInputActionOrigin_Switch_JoyConButton_E, // X + k_EInputActionOrigin_Switch_JoyConButton_S, // A + k_EInputActionOrigin_Switch_JoyConButton_W, // B + k_EInputActionOrigin_Switch_Reserved15, + k_EInputActionOrigin_Switch_Reserved16, + k_EInputActionOrigin_Switch_Reserved17, + k_EInputActionOrigin_Switch_Reserved18, + k_EInputActionOrigin_Switch_Reserved19, + k_EInputActionOrigin_Switch_Reserved20, + + // Added in SDK 1.51 + k_EInputActionOrigin_PS5_X, + k_EInputActionOrigin_PS5_Circle, + k_EInputActionOrigin_PS5_Triangle, + k_EInputActionOrigin_PS5_Square, + k_EInputActionOrigin_PS5_LeftBumper, + k_EInputActionOrigin_PS5_RightBumper, + k_EInputActionOrigin_PS5_Option, //Start + k_EInputActionOrigin_PS5_Create, //Back + k_EInputActionOrigin_PS5_Mute, + k_EInputActionOrigin_PS5_LeftPad_Touch, + k_EInputActionOrigin_PS5_LeftPad_Swipe, + k_EInputActionOrigin_PS5_LeftPad_Click, + k_EInputActionOrigin_PS5_LeftPad_DPadNorth, + k_EInputActionOrigin_PS5_LeftPad_DPadSouth, + k_EInputActionOrigin_PS5_LeftPad_DPadWest, + k_EInputActionOrigin_PS5_LeftPad_DPadEast, + k_EInputActionOrigin_PS5_RightPad_Touch, + k_EInputActionOrigin_PS5_RightPad_Swipe, + k_EInputActionOrigin_PS5_RightPad_Click, + k_EInputActionOrigin_PS5_RightPad_DPadNorth, + k_EInputActionOrigin_PS5_RightPad_DPadSouth, + k_EInputActionOrigin_PS5_RightPad_DPadWest, + k_EInputActionOrigin_PS5_RightPad_DPadEast, + k_EInputActionOrigin_PS5_CenterPad_Touch, + k_EInputActionOrigin_PS5_CenterPad_Swipe, + k_EInputActionOrigin_PS5_CenterPad_Click, + k_EInputActionOrigin_PS5_CenterPad_DPadNorth, + k_EInputActionOrigin_PS5_CenterPad_DPadSouth, + k_EInputActionOrigin_PS5_CenterPad_DPadWest, + k_EInputActionOrigin_PS5_CenterPad_DPadEast, + k_EInputActionOrigin_PS5_LeftTrigger_Pull, + k_EInputActionOrigin_PS5_LeftTrigger_Click, + k_EInputActionOrigin_PS5_RightTrigger_Pull, + k_EInputActionOrigin_PS5_RightTrigger_Click, + k_EInputActionOrigin_PS5_LeftStick_Move, + k_EInputActionOrigin_PS5_LeftStick_Click, + k_EInputActionOrigin_PS5_LeftStick_DPadNorth, + k_EInputActionOrigin_PS5_LeftStick_DPadSouth, + k_EInputActionOrigin_PS5_LeftStick_DPadWest, + k_EInputActionOrigin_PS5_LeftStick_DPadEast, + k_EInputActionOrigin_PS5_RightStick_Move, + k_EInputActionOrigin_PS5_RightStick_Click, + k_EInputActionOrigin_PS5_RightStick_DPadNorth, + k_EInputActionOrigin_PS5_RightStick_DPadSouth, + k_EInputActionOrigin_PS5_RightStick_DPadWest, + k_EInputActionOrigin_PS5_RightStick_DPadEast, + k_EInputActionOrigin_PS5_DPad_North, + k_EInputActionOrigin_PS5_DPad_South, + k_EInputActionOrigin_PS5_DPad_West, + k_EInputActionOrigin_PS5_DPad_East, + k_EInputActionOrigin_PS5_Gyro_Move, + k_EInputActionOrigin_PS5_Gyro_Pitch, + k_EInputActionOrigin_PS5_Gyro_Yaw, + k_EInputActionOrigin_PS5_Gyro_Roll, + k_EInputActionOrigin_PS5_DPad_Move, + k_EInputActionOrigin_PS5_LeftGrip, + k_EInputActionOrigin_PS5_RightGrip, + k_EInputActionOrigin_PS5_LeftFn, + k_EInputActionOrigin_PS5_RightFn, + k_EInputActionOrigin_PS5_Reserved5, + k_EInputActionOrigin_PS5_Reserved6, + k_EInputActionOrigin_PS5_Reserved7, + k_EInputActionOrigin_PS5_Reserved8, + k_EInputActionOrigin_PS5_Reserved9, + k_EInputActionOrigin_PS5_Reserved10, + k_EInputActionOrigin_PS5_Reserved11, + k_EInputActionOrigin_PS5_Reserved12, + k_EInputActionOrigin_PS5_Reserved13, + k_EInputActionOrigin_PS5_Reserved14, + k_EInputActionOrigin_PS5_Reserved15, + k_EInputActionOrigin_PS5_Reserved16, + k_EInputActionOrigin_PS5_Reserved17, + k_EInputActionOrigin_PS5_Reserved18, + k_EInputActionOrigin_PS5_Reserved19, + k_EInputActionOrigin_PS5_Reserved20, + + // Added in SDK 1.53 + k_EInputActionOrigin_SteamDeck_A, + k_EInputActionOrigin_SteamDeck_B, + k_EInputActionOrigin_SteamDeck_X, + k_EInputActionOrigin_SteamDeck_Y, + k_EInputActionOrigin_SteamDeck_L1, + k_EInputActionOrigin_SteamDeck_R1, + k_EInputActionOrigin_SteamDeck_Menu, + k_EInputActionOrigin_SteamDeck_View, + k_EInputActionOrigin_SteamDeck_LeftPad_Touch, + k_EInputActionOrigin_SteamDeck_LeftPad_Swipe, + k_EInputActionOrigin_SteamDeck_LeftPad_Click, + k_EInputActionOrigin_SteamDeck_LeftPad_DPadNorth, + k_EInputActionOrigin_SteamDeck_LeftPad_DPadSouth, + k_EInputActionOrigin_SteamDeck_LeftPad_DPadWest, + k_EInputActionOrigin_SteamDeck_LeftPad_DPadEast, + k_EInputActionOrigin_SteamDeck_RightPad_Touch, + k_EInputActionOrigin_SteamDeck_RightPad_Swipe, + k_EInputActionOrigin_SteamDeck_RightPad_Click, + k_EInputActionOrigin_SteamDeck_RightPad_DPadNorth, + k_EInputActionOrigin_SteamDeck_RightPad_DPadSouth, + k_EInputActionOrigin_SteamDeck_RightPad_DPadWest, + k_EInputActionOrigin_SteamDeck_RightPad_DPadEast, + k_EInputActionOrigin_SteamDeck_L2_SoftPull, + k_EInputActionOrigin_SteamDeck_L2, + k_EInputActionOrigin_SteamDeck_R2_SoftPull, + k_EInputActionOrigin_SteamDeck_R2, + k_EInputActionOrigin_SteamDeck_LeftStick_Move, + k_EInputActionOrigin_SteamDeck_L3, + k_EInputActionOrigin_SteamDeck_LeftStick_DPadNorth, + k_EInputActionOrigin_SteamDeck_LeftStick_DPadSouth, + k_EInputActionOrigin_SteamDeck_LeftStick_DPadWest, + k_EInputActionOrigin_SteamDeck_LeftStick_DPadEast, + k_EInputActionOrigin_SteamDeck_LeftStick_Touch, + k_EInputActionOrigin_SteamDeck_RightStick_Move, + k_EInputActionOrigin_SteamDeck_R3, + k_EInputActionOrigin_SteamDeck_RightStick_DPadNorth, + k_EInputActionOrigin_SteamDeck_RightStick_DPadSouth, + k_EInputActionOrigin_SteamDeck_RightStick_DPadWest, + k_EInputActionOrigin_SteamDeck_RightStick_DPadEast, + k_EInputActionOrigin_SteamDeck_RightStick_Touch, + k_EInputActionOrigin_SteamDeck_L4, + k_EInputActionOrigin_SteamDeck_R4, + k_EInputActionOrigin_SteamDeck_L5, + k_EInputActionOrigin_SteamDeck_R5, + k_EInputActionOrigin_SteamDeck_DPad_Move, + k_EInputActionOrigin_SteamDeck_DPad_North, + k_EInputActionOrigin_SteamDeck_DPad_South, + k_EInputActionOrigin_SteamDeck_DPad_West, + k_EInputActionOrigin_SteamDeck_DPad_East, + k_EInputActionOrigin_SteamDeck_Gyro_Move, + k_EInputActionOrigin_SteamDeck_Gyro_Pitch, + k_EInputActionOrigin_SteamDeck_Gyro_Yaw, + k_EInputActionOrigin_SteamDeck_Gyro_Roll, + k_EInputActionOrigin_SteamDeck_Reserved1, + k_EInputActionOrigin_SteamDeck_Reserved2, + k_EInputActionOrigin_SteamDeck_Reserved3, + k_EInputActionOrigin_SteamDeck_Reserved4, + k_EInputActionOrigin_SteamDeck_Reserved5, + k_EInputActionOrigin_SteamDeck_Reserved6, + k_EInputActionOrigin_SteamDeck_Reserved7, + k_EInputActionOrigin_SteamDeck_Reserved8, + k_EInputActionOrigin_SteamDeck_Reserved9, + k_EInputActionOrigin_SteamDeck_Reserved10, + k_EInputActionOrigin_SteamDeck_Reserved11, + k_EInputActionOrigin_SteamDeck_Reserved12, + k_EInputActionOrigin_SteamDeck_Reserved13, + k_EInputActionOrigin_SteamDeck_Reserved14, + k_EInputActionOrigin_SteamDeck_Reserved15, + k_EInputActionOrigin_SteamDeck_Reserved16, + k_EInputActionOrigin_SteamDeck_Reserved17, + k_EInputActionOrigin_SteamDeck_Reserved18, + k_EInputActionOrigin_SteamDeck_Reserved19, + k_EInputActionOrigin_SteamDeck_Reserved20, + + k_EInputActionOrigin_Count, // If Steam has added support for new controllers origins will go here. + k_EInputActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits. +}; + +enum EXboxOrigin +{ + k_EXboxOrigin_A, + k_EXboxOrigin_B, + k_EXboxOrigin_X, + k_EXboxOrigin_Y, + k_EXboxOrigin_LeftBumper, + k_EXboxOrigin_RightBumper, + k_EXboxOrigin_Menu, //Start + k_EXboxOrigin_View, //Back + k_EXboxOrigin_LeftTrigger_Pull, + k_EXboxOrigin_LeftTrigger_Click, + k_EXboxOrigin_RightTrigger_Pull, + k_EXboxOrigin_RightTrigger_Click, + k_EXboxOrigin_LeftStick_Move, + k_EXboxOrigin_LeftStick_Click, + k_EXboxOrigin_LeftStick_DPadNorth, + k_EXboxOrigin_LeftStick_DPadSouth, + k_EXboxOrigin_LeftStick_DPadWest, + k_EXboxOrigin_LeftStick_DPadEast, + k_EXboxOrigin_RightStick_Move, + k_EXboxOrigin_RightStick_Click, + k_EXboxOrigin_RightStick_DPadNorth, + k_EXboxOrigin_RightStick_DPadSouth, + k_EXboxOrigin_RightStick_DPadWest, + k_EXboxOrigin_RightStick_DPadEast, + k_EXboxOrigin_DPad_North, + k_EXboxOrigin_DPad_South, + k_EXboxOrigin_DPad_West, + k_EXboxOrigin_DPad_East, + k_EXboxOrigin_Count, +}; + +enum ESteamControllerPad +{ + k_ESteamControllerPad_Left, + k_ESteamControllerPad_Right +}; + +enum EControllerHapticLocation +{ + k_EControllerHapticLocation_Left = ( 1 << k_ESteamControllerPad_Left ), + k_EControllerHapticLocation_Right = ( 1 << k_ESteamControllerPad_Right ), + k_EControllerHapticLocation_Both = ( 1 << k_ESteamControllerPad_Left | 1 << k_ESteamControllerPad_Right ), +}; + +enum EControllerHapticType +{ + k_EControllerHapticType_Off, + k_EControllerHapticType_Tick, + k_EControllerHapticType_Click, +}; + +enum ESteamInputType +{ + k_ESteamInputType_Unknown, + k_ESteamInputType_SteamController, + k_ESteamInputType_XBox360Controller, + k_ESteamInputType_XBoxOneController, + k_ESteamInputType_GenericGamepad, // DirectInput controllers + k_ESteamInputType_PS4Controller, + k_ESteamInputType_AppleMFiController, // Unused + k_ESteamInputType_AndroidController, // Unused + k_ESteamInputType_SwitchJoyConPair, // Unused + k_ESteamInputType_SwitchJoyConSingle, // Unused + k_ESteamInputType_SwitchProController, + k_ESteamInputType_MobileTouch, // Steam Link App On-screen Virtual Controller + k_ESteamInputType_PS3Controller, // Currently uses PS4 Origins + k_ESteamInputType_PS5Controller, // Added in SDK 151 + k_ESteamInputType_SteamDeckController, // Added in SDK 153 + k_ESteamInputType_Count, + k_ESteamInputType_MaximumPossibleValue = 255, +}; + +// Individual values are used by the GetSessionInputConfigurationSettings bitmask +enum ESteamInputConfigurationEnableType +{ + k_ESteamInputConfigurationEnableType_None = 0x0000, + k_ESteamInputConfigurationEnableType_Playstation = 0x0001, + k_ESteamInputConfigurationEnableType_Xbox = 0x0002, + k_ESteamInputConfigurationEnableType_Generic = 0x0004, + k_ESteamInputConfigurationEnableType_Switch = 0x0008, +}; + +// These values are passed into SetLEDColor +enum ESteamInputLEDFlag +{ + k_ESteamInputLEDFlag_SetColor, + // Restore the LED color to the user's preference setting as set in the controller personalization menu. + // This also happens automatically on exit of your game. + k_ESteamInputLEDFlag_RestoreUserDefault +}; + +// These values are passed into GetGlyphPNGForActionOrigin +enum ESteamInputGlyphSize +{ + k_ESteamInputGlyphSize_Small, // 32x32 pixels + k_ESteamInputGlyphSize_Medium, // 128x128 pixels + k_ESteamInputGlyphSize_Large, // 256x256 pixels + k_ESteamInputGlyphSize_Count, +}; + +enum ESteamInputGlyphStyle +{ + // Base-styles - cannot mix + ESteamInputGlyphStyle_Knockout = 0x0, // Face buttons will have colored labels/outlines on a knocked out background + // Rest of inputs will have white detail/borders on a knocked out background + ESteamInputGlyphStyle_Light = 0x1, // Black detail/borders on a white background + ESteamInputGlyphStyle_Dark = 0x2, // White detail/borders on a black background + + // Modifiers + // Default ABXY/PS equivalent glyphs have a solid fill w/ color matching the physical buttons on the device + ESteamInputGlyphStyle_NeutralColorABXY = 0x10, // ABXY Buttons will match the base style color instead of their normal associated color + ESteamInputGlyphStyle_SolidABXY = 0x20, // ABXY Buttons will have a solid fill +}; + +enum ESteamInputActionEventType +{ + ESteamInputActionEventType_DigitalAction, + ESteamInputActionEventType_AnalogAction, +}; + +// InputHandle_t is used to refer to a specific controller. +// This handle will consistently identify a controller, even if it is disconnected and re-connected +typedef uint64 InputHandle_t; + +// These handles are used to refer to a specific in-game action or action set +// All action handles should be queried during initialization for performance reasons +typedef uint64 InputActionSetHandle_t; +typedef uint64 InputDigitalActionHandle_t; +typedef uint64 InputAnalogActionHandle_t; + +#pragma pack( push, 1 ) + +struct InputAnalogActionData_t +{ + // Type of data coming from this action, this will match what got specified in the action set + EInputSourceMode eMode; + + // The current state of this action; will be delta updates for mouse actions + float x, y; + + // Whether or not this action is currently available to be bound in the active action set + bool bActive; +}; + +struct InputDigitalActionData_t +{ + // The current state of this action; will be true if currently pressed + bool bState; + + // Whether or not this action is currently available to be bound in the active action set + bool bActive; +}; + +struct InputMotionData_t +{ + // Sensor-fused absolute rotation; will drift in heading toward average + float rotQuatX; + float rotQuatY; + float rotQuatZ; + float rotQuatW; + + // Positional acceleration + float posAccelX; + float posAccelY; + float posAccelZ; + + // Angular velocity + float rotVelX; + float rotVelY; + float rotVelZ; +}; + +//----------------------------------------------------------------------------- +// Purpose: when callbacks are enabled this fires each time a controller action +// state changes +//----------------------------------------------------------------------------- +struct SteamInputActionEvent_t +{ + InputHandle_t controllerHandle; + ESteamInputActionEventType eEventType; + struct AnalogAction_t { + InputAnalogActionHandle_t actionHandle; + InputAnalogActionData_t analogActionData; + }; + struct DigitalAction_t { + InputDigitalActionHandle_t actionHandle; + InputDigitalActionData_t digitalActionData; + }; + union { + AnalogAction_t analogAction; + DigitalAction_t digitalAction; + } x; +}; + +//----------------------------------------------------------------------------- +// Forward declaration for ScePadTriggerEffectParam, defined in isteamdualsense.h +//----------------------------------------------------------------------------- +struct ScePadTriggerEffectParam; + +#pragma pack( pop ) + +typedef void ( *SteamInputActionEventCallbackPointer )( SteamInputActionEvent_t * ); + +//----------------------------------------------------------------------------- +// Purpose: Steam Input API +//----------------------------------------------------------------------------- +class ISteamInput +{ +public: + + // Init and Shutdown must be called when starting/ending use of this interface. + // if bExplicitlyCallRunFrame is called then you will need to manually call RunFrame + // each frame, otherwise Steam Input will updated when SteamAPI_RunCallbacks() is called + virtual bool Init( bool bExplicitlyCallRunFrame ) = 0; + virtual bool Shutdown() = 0; + + // Set the absolute path to the Input Action Manifest file containing the in-game actions + // and file paths to the official configurations. Used in games that bundle Steam Input + // configurations inside of the game depot instead of using the Steam Workshop + virtual bool SetInputActionManifestFilePath( const char *pchInputActionManifestAbsolutePath ) = 0; + + // Synchronize API state with the latest Steam Input action data available. This + // is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest + // possible latency, you call this directly before reading controller state. + // Note: This must be called from somewhere before GetConnectedControllers will + // return any handles + virtual void RunFrame( bool bReservedValue = true ) = 0; + + // Waits on an IPC event from Steam sent when there is new data to be fetched from + // the data drop. Returns true when data was recievied before the timeout expires. + // Useful for games with a dedicated input thread + virtual bool BWaitForData( bool bWaitForever, uint32 unTimeout ) = 0; + + // Returns true if new data has been received since the last time action data was accessed + // via GetDigitalActionData or GetAnalogActionData. The game will still need to call + // SteamInput()->RunFrame() or SteamAPI_RunCallbacks() before this to update the data stream + virtual bool BNewDataAvailable() = 0; + + // Enumerate currently connected Steam Input enabled devices - developers can opt in controller by type (ex: Xbox/Playstation/etc) via + // the Steam Input settings in the Steamworks site or users can opt-in in their controller settings in Steam. + // handlesOut should point to a STEAM_INPUT_MAX_COUNT sized array of InputHandle_t handles + // Returns the number of handles written to handlesOut + virtual int GetConnectedControllers( STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_COUNT, Receives list of connected controllers ) InputHandle_t *handlesOut ) = 0; + + //----------------------------------------------------------------------------- + // CALLBACKS + //----------------------------------------------------------------------------- + + // Controller configuration loaded - these callbacks will always fire if you have + // a handler. Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks + STEAM_CALL_BACK( SteamInputConfigurationLoaded_t ) + + // Enable SteamInputDeviceConnected_t and SteamInputDeviceDisconnected_t callbacks. + // Each controller that is already connected will generate a device connected + // callback when you enable them + virtual void EnableDeviceCallbacks() = 0; + + // Controller Connected - provides info about a single newly connected controller + // Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks + STEAM_CALL_BACK( SteamInputDeviceConnected_t ) + + // Controller Disconnected - provides info about a single disconnected controller + // Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks + STEAM_CALL_BACK( SteamInputDeviceDisconnected_t ) + + // Controllers using Gamepad emulation (XInput, DirectInput, etc) will be seated in the order that + // input is sent by the device. This callback will fire on first input for each device and when the + // a user has manually changed the order via the Steam overlay. This also has the device type info + // so that you can change out glyph sets without making additional API calls + STEAM_CALL_BACK( SteamInputGamepadSlotChange_t ) + + // Enable SteamInputActionEvent_t callbacks. Directly calls your callback function + // for lower latency than standard Steam callbacks. Supports one callback at a time. + // Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks + virtual void EnableActionEventCallbacks( SteamInputActionEventCallbackPointer pCallback ) = 0; + + //----------------------------------------------------------------------------- + // ACTION SETS + //----------------------------------------------------------------------------- + + // Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls. + virtual InputActionSetHandle_t GetActionSetHandle( const char *pszActionSetName ) = 0; + + // Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive') + // This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in + // your state loops, instead of trying to place it in all of your state transitions. + virtual void ActivateActionSet( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle ) = 0; + virtual InputActionSetHandle_t GetCurrentActionSet( InputHandle_t inputHandle ) = 0; + + // ACTION SET LAYERS + virtual void ActivateActionSetLayer( InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ) = 0; + virtual void DeactivateActionSetLayer( InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ) = 0; + virtual void DeactivateAllActionSetLayers( InputHandle_t inputHandle ) = 0; + + // Enumerate currently active layers. + // handlesOut should point to a STEAM_INPUT_MAX_ACTIVE_LAYERS sized array of InputActionSetHandle_t handles + // Returns the number of handles written to handlesOut + virtual int GetActiveActionSetLayers( InputHandle_t inputHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ACTIVE_LAYERS, Receives list of active layers ) InputActionSetHandle_t *handlesOut ) = 0; + + //----------------------------------------------------------------------------- + // ACTIONS + //----------------------------------------------------------------------------- + + // Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls. + virtual InputDigitalActionHandle_t GetDigitalActionHandle( const char *pszActionName ) = 0; + + // Returns the current state of the supplied digital game action + virtual InputDigitalActionData_t GetDigitalActionData( InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle ) = 0; + + // Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. + // originsOut should point to a STEAM_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to + // the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. + virtual int GetDigitalActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ORIGINS, Receives list of action origins ) EInputActionOrigin *originsOut ) = 0; + + // Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle + virtual const char *GetStringForDigitalActionName( InputDigitalActionHandle_t eActionHandle ) = 0; + + // Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls. + virtual InputAnalogActionHandle_t GetAnalogActionHandle( const char *pszActionName ) = 0; + + // Returns the current state of these supplied analog game action + virtual InputAnalogActionData_t GetAnalogActionData( InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle ) = 0; + + // Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. + // originsOut should point to a STEAM_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to + // the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. + virtual int GetAnalogActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ORIGINS, Receives list of action origins ) EInputActionOrigin *originsOut ) = 0; + + // Get a local path to a PNG file for the provided origin's glyph. + virtual const char *GetGlyphPNGForActionOrigin( EInputActionOrigin eOrigin, ESteamInputGlyphSize eSize, uint32 unFlags ) = 0; + + // Get a local path to a SVG file for the provided origin's glyph. + virtual const char *GetGlyphSVGForActionOrigin( EInputActionOrigin eOrigin, uint32 unFlags ) = 0; + + // Get a local path to an older, Big Picture Mode-style PNG file for a particular origin + virtual const char *GetGlyphForActionOrigin_Legacy( EInputActionOrigin eOrigin ) = 0; + + // Returns a localized string (from Steam's language setting) for the specified origin. + virtual const char *GetStringForActionOrigin( EInputActionOrigin eOrigin ) = 0; + + // Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle + virtual const char *GetStringForAnalogActionName( InputAnalogActionHandle_t eActionHandle ) = 0; + + // Stop analog momentum for the action if it is a mouse action in trackball mode + virtual void StopAnalogActionMomentum( InputHandle_t inputHandle, InputAnalogActionHandle_t eAction ) = 0; + + // Returns raw motion data from the specified device + virtual InputMotionData_t GetMotionData( InputHandle_t inputHandle ) = 0; + + //----------------------------------------------------------------------------- + // OUTPUTS + //----------------------------------------------------------------------------- + + // Trigger a vibration event on supported controllers - Steam will translate these commands into haptic pulses for Steam Controllers + virtual void TriggerVibration( InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ) = 0; + + // Trigger a vibration event on supported controllers including Xbox trigger impulse rumble - Steam will translate these commands into haptic pulses for Steam Controllers + virtual void TriggerVibrationExtended( InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed, unsigned short usLeftTriggerSpeed, unsigned short usRightTriggerSpeed ) = 0; + + // Send a haptic pulse, works on Steam Deck and Steam Controller devices + virtual void TriggerSimpleHapticEvent( InputHandle_t inputHandle, EControllerHapticLocation eHapticLocation, uint8 nIntensity, char nGainDB, uint8 nOtherIntensity, char nOtherGainDB ) = 0; + + // Set the controller LED color on supported controllers. nFlags is a bitmask of values from ESteamInputLEDFlag - 0 will default to setting a color. Steam will handle + // the behavior on exit of your program so you don't need to try restore the default as you are shutting down + virtual void SetLEDColor( InputHandle_t inputHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ) = 0; + + // Trigger a haptic pulse on a Steam Controller - if you are approximating rumble you may want to use TriggerVibration instead. + // Good uses for Haptic pulses include chimes, noises, or directional gameplay feedback (taking damage, footstep locations, etc). + virtual void Legacy_TriggerHapticPulse( InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0; + + // Trigger a haptic pulse with a duty cycle of usDurationMicroSec / usOffMicroSec, unRepeat times. If you are approximating rumble you may want to use TriggerVibration instead. + // nFlags is currently unused and reserved for future use. + virtual void Legacy_TriggerRepeatedHapticPulse( InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ) = 0; + + //----------------------------------------------------------------------------- + // Utility functions available without using the rest of Steam Input API + //----------------------------------------------------------------------------- + + // Invokes the Steam overlay and brings up the binding screen if the user is using Big Picture Mode + // If the user is not in Big Picture Mode it will open up the binding in a new window + virtual bool ShowBindingPanel( InputHandle_t inputHandle ) = 0; + + // Returns the input type for a particular handle - unlike EInputActionOrigin which update with Steam and may return unrecognized values + // ESteamInputType will remain static and only return valid values from your SDK version + virtual ESteamInputType GetInputTypeForHandle( InputHandle_t inputHandle ) = 0; + + // Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions + // to identify controllers presented to your game over Xinput. Returns 0 if the Xinput index isn't associated with Steam Input + virtual InputHandle_t GetControllerForGamepadIndex( int nIndex ) = 0; + + // Returns the associated gamepad index for the specified controller, if emulating a gamepad or -1 if not associated with an Xinput index + virtual int GetGamepadIndexForController( InputHandle_t ulinputHandle ) = 0; + + // Returns a localized string (from Steam's language setting) for the specified Xbox controller origin. + virtual const char *GetStringForXboxOrigin( EXboxOrigin eOrigin ) = 0; + + // Get a local path to art for on-screen glyph for a particular Xbox controller origin + virtual const char *GetGlyphForXboxOrigin( EXboxOrigin eOrigin ) = 0; + + // Get the equivalent ActionOrigin for a given Xbox controller origin this can be chained with GetGlyphForActionOrigin to provide future proof glyphs for + // non-Steam Input API action games. Note - this only translates the buttons directly and doesn't take into account any remapping a user has made in their configuration + virtual EInputActionOrigin GetActionOriginFromXboxOrigin( InputHandle_t inputHandle, EXboxOrigin eOrigin ) = 0; + + // Convert an origin to another controller type - for inputs not present on the other controller type this will return k_EInputActionOrigin_None + // When a new input type is added you will be able to pass in k_ESteamInputType_Unknown and the closest origin that your version of the SDK recognized will be returned + // ex: if a Playstation 5 controller was released this function would return Playstation 4 origins. + virtual EInputActionOrigin TranslateActionOrigin( ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin ) = 0; + + // Get the binding revision for a given device. Returns false if the handle was not valid or if a mapping is not yet loaded for the device + virtual bool GetDeviceBindingRevision( InputHandle_t inputHandle, int *pMajor, int *pMinor ) = 0; + + // Get the Steam Remote Play session ID associated with a device, or 0 if there is no session associated with it + // See isteamremoteplay.h for more information on Steam Remote Play sessions + virtual uint32 GetRemotePlaySessionID( InputHandle_t inputHandle ) = 0; + + // Get a bitmask of the Steam Input Configuration types opted in for the current session. Returns ESteamInputConfigurationEnableType values. + // Note: user can override the settings from the Steamworks Partner site so the returned values may not exactly match your default configuration + virtual uint16 GetSessionInputConfigurationSettings() = 0; + + // Set the trigger effect for a DualSense controller + virtual void SetDualSenseTriggerEffect( InputHandle_t inputHandle, const ScePadTriggerEffectParam *pParam ) = 0; +}; + +#define STEAMINPUT_INTERFACE_VERSION "SteamInput006" + +// Global interface accessor +inline ISteamInput *SteamInput(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamInput *, SteamInput, STEAMINPUT_INTERFACE_VERSION ); + +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: called when a new controller has been connected, will fire once +// per controller if multiple new controllers connect in the same frame +//----------------------------------------------------------------------------- +struct SteamInputDeviceConnected_t +{ + enum { k_iCallback = k_iSteamControllerCallbacks + 1 }; + InputHandle_t m_ulConnectedDeviceHandle; // Handle for device +}; + +//----------------------------------------------------------------------------- +// Purpose: called when a new controller has been connected, will fire once +// per controller if multiple new controllers connect in the same frame +//----------------------------------------------------------------------------- +struct SteamInputDeviceDisconnected_t +{ + enum { k_iCallback = k_iSteamControllerCallbacks + 2 }; + InputHandle_t m_ulDisconnectedDeviceHandle; // Handle for device +}; + +//----------------------------------------------------------------------------- +// Purpose: called when a controller configuration has been loaded, will fire once +// per controller per focus change for Steam Input enabled controllers +//----------------------------------------------------------------------------- +struct SteamInputConfigurationLoaded_t +{ + enum { k_iCallback = k_iSteamControllerCallbacks + 3 }; + AppId_t m_unAppID; + InputHandle_t m_ulDeviceHandle; // Handle for device + CSteamID m_ulMappingCreator; // May differ from local user when using + // an unmodified community or official config + uint32 m_unMajorRevision; // Binding revision from In-game Action File. + // Same value as queried by GetDeviceBindingRevision + uint32 m_unMinorRevision; + bool m_bUsesSteamInputAPI; // Does the configuration contain any Analog/Digital actions? + bool m_bUsesGamepadAPI; // Does the configuration contain any Xinput bindings? +}; + +//----------------------------------------------------------------------------- +// Purpose: called when controller gamepad slots change - on Linux/macOS these +// slots are shared for all running apps. +//----------------------------------------------------------------------------- +struct SteamInputGamepadSlotChange_t +{ + enum { k_iCallback = k_iSteamControllerCallbacks + 4 }; + AppId_t m_unAppID; + InputHandle_t m_ulDeviceHandle; // Handle for device + ESteamInputType m_eDeviceType; // Type of device + int m_nOldGamepadSlot; // Previous GamepadSlot - can be -1 controller doesn't uses gamepad bindings + int m_nNewGamepadSlot; // New Gamepad Slot - can be -1 controller doesn't uses gamepad bindings +}; + +#pragma pack( pop ) + +#endif // ISTEAMINPUT_H diff --git a/lsteamclient/steamworks_sdk_160/isteaminventory.h b/lsteamclient/steamworks_sdk_160/isteaminventory.h new file mode 100644 index 0000000000..7066592078 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteaminventory.h @@ -0,0 +1,435 @@ +//====== Copyright © 1996-2014 Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to Steam Inventory +// +//============================================================================= + +#ifndef ISTEAMINVENTORY_H +#define ISTEAMINVENTORY_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +// Every individual instance of an item has a globally-unique ItemInstanceID. +// This ID is unique to the combination of (player, specific item instance) +// and will not be transferred to another player or re-used for another item. +typedef uint64 SteamItemInstanceID_t; + +static const SteamItemInstanceID_t k_SteamItemInstanceIDInvalid = (SteamItemInstanceID_t)~0; + +// Types of items in your game are identified by a 32-bit "item definition number". +// Valid definition numbers are between 1 and 999999999; numbers less than or equal to +// zero are invalid, and numbers greater than or equal to one billion (1x10^9) are +// reserved for internal Steam use. +typedef int32 SteamItemDef_t; + + +enum ESteamItemFlags +{ + // Item status flags - these flags are permanently attached to specific item instances + k_ESteamItemNoTrade = 1 << 0, // This item is account-locked and cannot be traded or given away. + + // Action confirmation flags - these flags are set one time only, as part of a result set + k_ESteamItemRemoved = 1 << 8, // The item has been destroyed, traded away, expired, or otherwise invalidated + k_ESteamItemConsumed = 1 << 9, // The item quantity has been decreased by 1 via ConsumeItem API. + + // All other flag bits are currently reserved for internal Steam use at this time. + // Do not assume anything about the state of other flags which are not defined here. +}; + +struct SteamItemDetails_t +{ + SteamItemInstanceID_t m_itemId; + SteamItemDef_t m_iDefinition; + uint16 m_unQuantity; + uint16 m_unFlags; // see ESteamItemFlags +}; + +typedef int32 SteamInventoryResult_t; + +static const SteamInventoryResult_t k_SteamInventoryResultInvalid = -1; + +typedef uint64 SteamInventoryUpdateHandle_t; +const SteamInventoryUpdateHandle_t k_SteamInventoryUpdateHandleInvalid = 0xffffffffffffffffull; + +//----------------------------------------------------------------------------- +// Purpose: Steam Inventory query and manipulation API +//----------------------------------------------------------------------------- +class ISteamInventory +{ +public: + + // INVENTORY ASYNC RESULT MANAGEMENT + // + // Asynchronous inventory queries always output a result handle which can be used with + // GetResultStatus, GetResultItems, etc. A SteamInventoryResultReady_t callback will + // be triggered when the asynchronous result becomes ready (or fails). + // + + // Find out the status of an asynchronous inventory result handle. Possible values: + // k_EResultPending - still in progress + // k_EResultOK - done, result ready + // k_EResultExpired - done, result ready, maybe out of date (see DeserializeResult) + // k_EResultInvalidParam - ERROR: invalid API call parameters + // k_EResultServiceUnavailable - ERROR: service temporarily down, you may retry later + // k_EResultLimitExceeded - ERROR: operation would exceed per-user inventory limits + // k_EResultFail - ERROR: unknown / generic error + virtual EResult GetResultStatus( SteamInventoryResult_t resultHandle ) = 0; + + // Copies the contents of a result set into a flat array. The specific + // contents of the result set depend on which query which was used. + virtual bool GetResultItems( SteamInventoryResult_t resultHandle, + STEAM_OUT_ARRAY_COUNT( punOutItemsArraySize,Output array) SteamItemDetails_t *pOutItemsArray, + uint32 *punOutItemsArraySize ) = 0; + + // In combination with GetResultItems, you can use GetResultItemProperty to retrieve + // dynamic string properties for a given item returned in the result set. + // + // Property names are always composed of ASCII letters, numbers, and/or underscores. + // + // Pass a NULL pointer for pchPropertyName to get a comma - separated list of available + // property names. + // + // If pchValueBuffer is NULL, *punValueBufferSize will contain the + // suggested buffer size. Otherwise it will be the number of bytes actually copied + // to pchValueBuffer. If the results do not fit in the given buffer, partial + // results may be copied. + virtual bool GetResultItemProperty( SteamInventoryResult_t resultHandle, + uint32 unItemIndex, + const char *pchPropertyName, + STEAM_OUT_STRING_COUNT( punValueBufferSizeOut ) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) = 0; + + // Returns the server time at which the result was generated. Compare against + // the value of IClientUtils::GetServerRealTime() to determine age. + virtual uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle ) = 0; + + // Returns true if the result belongs to the target steam ID, false if the + // result does not. This is important when using DeserializeResult, to verify + // that a remote player is not pretending to have a different user's inventory. + virtual bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected ) = 0; + + // Destroys a result handle and frees all associated memory. + virtual void DestroyResult( SteamInventoryResult_t resultHandle ) = 0; + + + // INVENTORY ASYNC QUERY + // + + // Captures the entire state of the current user's Steam inventory. + // You must call DestroyResult on this handle when you are done with it. + // Returns false and sets *pResultHandle to zero if inventory is unavailable. + // Note: calls to this function are subject to rate limits and may return + // cached results if called too frequently. It is suggested that you call + // this function only when you are about to display the user's full inventory, + // or if you expect that the inventory may have changed. + virtual bool GetAllItems( SteamInventoryResult_t *pResultHandle ) = 0; + + + // Captures the state of a subset of the current user's Steam inventory, + // identified by an array of item instance IDs. The results from this call + // can be serialized and passed to other players to "prove" that the current + // user owns specific items, without exposing the user's entire inventory. + // For example, you could call GetItemsByID with the IDs of the user's + // currently equipped cosmetic items and serialize this to a buffer, and + // then transmit this buffer to other players upon joining a game. + virtual bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unCountInstanceIDs ) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs ) = 0; + + + // RESULT SERIALIZATION AND AUTHENTICATION + // + // Serialized result sets contain a short signature which can't be forged + // or replayed across different game sessions. A result set can be serialized + // on the local client, transmitted to other players via your game networking, + // and deserialized by the remote players. This is a secure way of preventing + // hackers from lying about posessing rare/high-value items. + + // Serializes a result set with signature bytes to an output buffer. Pass + // NULL as an output buffer to get the required size via punOutBufferSize. + // The size of a serialized result depends on the number items which are being + // serialized. When securely transmitting items to other players, it is + // recommended to use "GetItemsByID" first to create a minimal result set. + // Results have a built-in timestamp which will be considered "expired" after + // an hour has elapsed. See DeserializeResult for expiration handling. + virtual bool SerializeResult( SteamInventoryResult_t resultHandle, STEAM_OUT_BUFFER_COUNT(punOutBufferSize) void *pOutBuffer, uint32 *punOutBufferSize ) = 0; + + // Deserializes a result set and verifies the signature bytes. Returns false + // if bRequireFullOnlineVerify is set but Steam is running in Offline mode. + // Otherwise returns true and then delivers error codes via GetResultStatus. + // + // The bRESERVED_MUST_BE_FALSE flag is reserved for future use and should not + // be set to true by your game at this time. + // + // DeserializeResult has a potential soft-failure mode where the handle status + // is set to k_EResultExpired. GetResultItems() still succeeds in this mode. + // The "expired" result could indicate that the data may be out of date - not + // just due to timed expiration (one hour), but also because one of the items + // in the result set may have been traded or consumed since the result set was + // generated. You could compare the timestamp from GetResultTimestamp() to + // ISteamUtils::GetServerRealTime() to determine how old the data is. You could + // simply ignore the "expired" result code and continue as normal, or you + // could challenge the player with expired data to send an updated result set. + virtual bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, STEAM_BUFFER_COUNT(punOutBufferSize) const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE = false ) = 0; + + + // INVENTORY ASYNC MODIFICATION + // + + // GenerateItems() creates one or more items and then generates a SteamInventoryCallback_t + // notification with a matching nCallbackContext parameter. This API is only intended + // for prototyping - it is only usable by Steam accounts that belong to the publisher group + // for your game. + // If punArrayQuantity is not NULL, it should be the same length as pArrayItems and should + // describe the quantity of each item to generate. + virtual bool GenerateItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength ) = 0; + + // GrantPromoItems() checks the list of promotional items for which the user may be eligible + // and grants the items (one time only). On success, the result set will include items which + // were granted, if any. If no items were granted because the user isn't eligible for any + // promotions, this is still considered a success. + virtual bool GrantPromoItems( SteamInventoryResult_t *pResultHandle ) = 0; + + // AddPromoItem() / AddPromoItems() are restricted versions of GrantPromoItems(). Instead of + // scanning for all eligible promotional items, the check is restricted to a single item + // definition or set of item definitions. This can be useful if your game has custom UI for + // showing a specific promo item to the user. + virtual bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef ) = 0; + virtual bool AddPromoItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength ) = 0; + + // ConsumeItem() removes items from the inventory, permanently. They cannot be recovered. + // Not for the faint of heart - if your game implements item removal at all, a high-friction + // UI confirmation process is highly recommended. + virtual bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity ) = 0; + + // ExchangeItems() is an atomic combination of item generation and consumption. + // It can be used to implement crafting recipes or transmutations, or items which unpack + // themselves into other items (e.g., a chest). + // Exchange recipes are defined in the ItemDef, and explicitly list the required item + // types and resulting generated type. + // Exchange recipes are evaluated atomically by the Inventory Service; if the supplied + // components do not match the recipe, or do not contain sufficient quantity, the + // exchange will fail. + virtual bool ExchangeItems( SteamInventoryResult_t *pResultHandle, + STEAM_ARRAY_COUNT(unArrayGenerateLength) const SteamItemDef_t *pArrayGenerate, STEAM_ARRAY_COUNT(unArrayGenerateLength) const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength, + STEAM_ARRAY_COUNT(unArrayDestroyLength) const SteamItemInstanceID_t *pArrayDestroy, STEAM_ARRAY_COUNT(unArrayDestroyLength) const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength ) = 0; + + + // TransferItemQuantity() is intended for use with items which are "stackable" (can have + // quantity greater than one). It can be used to split a stack into two, or to transfer + // quantity from one stack into another stack of identical items. To split one stack into + // two, pass k_SteamItemInstanceIDInvalid for itemIdDest and a new item will be generated. + virtual bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest ) = 0; + + + // TIMED DROPS AND PLAYTIME CREDIT + // + + // Deprecated. Calling this method is not required for proper playtime accounting. + virtual void SendItemDropHeartbeat() = 0; + + // Playtime credit must be consumed and turned into item drops by your game. Only item + // definitions which are marked as "playtime item generators" can be spawned. The call + // will return an empty result set if there is not enough playtime credit for a drop. + // Your game should call TriggerItemDrop at an appropriate time for the user to receive + // new items, such as between rounds or while the player is dead. Note that players who + // hack their clients could modify the value of "dropListDefinition", so do not use it + // to directly control rarity. + // See your Steamworks configuration to set playtime drop rates for individual itemdefs. + // The client library will suppress too-frequent calls to this method. + virtual bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition ) = 0; + + + // Deprecated. This method is not supported. + virtual bool TradeItems( SteamInventoryResult_t *pResultHandle, CSteamID steamIDTradePartner, + STEAM_ARRAY_COUNT(nArrayGiveLength) const SteamItemInstanceID_t *pArrayGive, STEAM_ARRAY_COUNT(nArrayGiveLength) const uint32 *pArrayGiveQuantity, uint32 nArrayGiveLength, + STEAM_ARRAY_COUNT(nArrayGetLength) const SteamItemInstanceID_t *pArrayGet, STEAM_ARRAY_COUNT(nArrayGetLength) const uint32 *pArrayGetQuantity, uint32 nArrayGetLength ) = 0; + + + // ITEM DEFINITIONS + // + // Item definitions are a mapping of "definition IDs" (integers between 1 and 1000000) + // to a set of string properties. Some of these properties are required to display items + // on the Steam community web site. Other properties can be defined by applications. + // Use of these functions is optional; there is no reason to call LoadItemDefinitions + // if your game hardcodes the numeric definition IDs (eg, purple face mask = 20, blue + // weapon mod = 55) and does not allow for adding new item types without a client patch. + // + + // LoadItemDefinitions triggers the automatic load and refresh of item definitions. + // Every time new item definitions are available (eg, from the dynamic addition of new + // item types while players are still in-game), a SteamInventoryDefinitionUpdate_t + // callback will be fired. + virtual bool LoadItemDefinitions() = 0; + + // GetItemDefinitionIDs returns the set of all defined item definition IDs (which are + // defined via Steamworks configuration, and not necessarily contiguous integers). + // If pItemDefIDs is null, the call will return true and *punItemDefIDsArraySize will + // contain the total size necessary for a subsequent call. Otherwise, the call will + // return false if and only if there is not enough space in the output array. + virtual bool GetItemDefinitionIDs( + STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, + STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize ) = 0; + + // GetItemDefinitionProperty returns a string property from a given item definition. + // Note that some properties (for example, "name") may be localized and will depend + // on the current Steam language settings (see ISteamApps::GetCurrentGameLanguage). + // Property names are always composed of ASCII letters, numbers, and/or underscores. + // Pass a NULL pointer for pchPropertyName to get a comma - separated list of available + // property names. If pchValueBuffer is NULL, *punValueBufferSize will contain the + // suggested buffer size. Otherwise it will be the number of bytes actually copied + // to pchValueBuffer. If the results do not fit in the given buffer, partial + // results may be copied. + virtual bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName, + STEAM_OUT_STRING_COUNT(punValueBufferSizeOut) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) = 0; + + // Request the list of "eligible" promo items that can be manually granted to the given + // user. These are promo items of type "manual" that won't be granted automatically. + // An example usage of this is an item that becomes available every week. + STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t ) + virtual SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID ) = 0; + + // After handling a SteamInventoryEligiblePromoItemDefIDs_t call result, use this + // function to pull out the list of item definition ids that the user can be + // manually granted via the AddPromoItems() call. + virtual bool GetEligiblePromoItemDefinitionIDs( + CSteamID steamID, + STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, + STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize ) = 0; + + // Starts the purchase process for the given item definitions. The callback SteamInventoryStartPurchaseResult_t + // will be posted if Steam was able to initialize the transaction. + // + // Once the purchase has been authorized and completed by the user, the callback SteamInventoryResultReady_t + // will be posted. + STEAM_CALL_RESULT( SteamInventoryStartPurchaseResult_t ) + virtual SteamAPICall_t StartPurchase( STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength ) = 0; + + // Request current prices for all applicable item definitions + STEAM_CALL_RESULT( SteamInventoryRequestPricesResult_t ) + virtual SteamAPICall_t RequestPrices() = 0; + + // Returns the number of items with prices. Need to call RequestPrices() first. + virtual uint32 GetNumItemsWithPrices() = 0; + + // Returns item definition ids and their prices in the user's local currency. + // Need to call RequestPrices() first. + virtual bool GetItemsWithPrices( STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pArrayItemDefs, Items with prices) SteamItemDef_t *pArrayItemDefs, + STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pCurrentPrices, + STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pBasePrices, + uint32 unArrayLength ) = 0; + + // Retrieves the price for the item definition id + // Returns false if there is no price stored for the item definition. + virtual bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice ) = 0; + + // Create a request to update properties on items + virtual SteamInventoryUpdateHandle_t StartUpdateProperties() = 0; + // Remove the property on the item + virtual bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName ) = 0; + // Accessor methods to set properties on items + + STEAM_FLAT_NAME( SetPropertyString ) + virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue ) = 0; + + STEAM_FLAT_NAME( SetPropertyBool ) + virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue ) = 0; + + STEAM_FLAT_NAME( SetPropertyInt64 ) + virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue ) = 0; + + STEAM_FLAT_NAME( SetPropertyFloat ) + virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue ) = 0; + + // Submit the update request by handle + virtual bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle ) = 0; + + virtual bool InspectItem( SteamInventoryResult_t *pResultHandle, const char *pchItemToken ) = 0; +}; + +#define STEAMINVENTORY_INTERFACE_VERSION "STEAMINVENTORY_INTERFACE_V003" + +// Global interface accessor +inline ISteamInventory *SteamInventory(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamInventory *, SteamInventory, STEAMINVENTORY_INTERFACE_VERSION ); + +// Global accessor for the gameserver client +inline ISteamInventory *SteamGameServerInventory(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamInventory *, SteamGameServerInventory, STEAMINVENTORY_INTERFACE_VERSION ); + +// SteamInventoryResultReady_t callbacks are fired whenever asynchronous +// results transition from "Pending" to "OK" or an error state. There will +// always be exactly one callback per handle. +struct SteamInventoryResultReady_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 0 }; + SteamInventoryResult_t m_handle; + EResult m_result; +}; + + +// SteamInventoryFullUpdate_t callbacks are triggered when GetAllItems +// successfully returns a result which is newer / fresher than the last +// known result. (It will not trigger if the inventory hasn't changed, +// or if results from two overlapping calls are reversed in flight and +// the earlier result is already known to be stale/out-of-date.) +// The normal ResultReady callback will still be triggered immediately +// afterwards; this is an additional notification for your convenience. +struct SteamInventoryFullUpdate_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 1 }; + SteamInventoryResult_t m_handle; +}; + + +// A SteamInventoryDefinitionUpdate_t callback is triggered whenever +// item definitions have been updated, which could be in response to +// LoadItemDefinitions() or any other async request which required +// a definition update in order to process results from the server. +struct SteamInventoryDefinitionUpdate_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 2 }; +}; + +// Returned +struct SteamInventoryEligiblePromoItemDefIDs_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 3 }; + EResult m_result; + CSteamID m_steamID; + int m_numEligiblePromoItemDefs; + bool m_bCachedData; // indicates that the data was retrieved from the cache and not the server +}; + +// Triggered from StartPurchase call +struct SteamInventoryStartPurchaseResult_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 4 }; + EResult m_result; + uint64 m_ulOrderID; + uint64 m_ulTransID; +}; + + +// Triggered from RequestPrices +struct SteamInventoryRequestPricesResult_t +{ + enum { k_iCallback = k_iSteamInventoryCallbacks + 5 }; + EResult m_result; + char m_rgchCurrency[4]; +}; + +#pragma pack( pop ) + + +#endif // ISTEAMCONTROLLER_H diff --git a/lsteamclient/steamworks_sdk_160/isteammatchmaking.h b/lsteamclient/steamworks_sdk_160/isteammatchmaking.h new file mode 100644 index 0000000000..12189c72b1 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteammatchmaking.h @@ -0,0 +1,1087 @@ +//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to steam managing game server/client match making +// +//============================================================================= + +#ifndef ISTEAMMATCHMAKING +#define ISTEAMMATCHMAKING +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "matchmakingtypes.h" +#include "isteamfriends.h" + +// lobby type description +enum ELobbyType +{ + k_ELobbyTypePrivate = 0, // only way to join the lobby is to invite to someone else + k_ELobbyTypeFriendsOnly = 1, // shows for friends or invitees, but not in lobby list + k_ELobbyTypePublic = 2, // visible for friends and in lobby list + k_ELobbyTypeInvisible = 3, // returned by search, but not visible to other friends + // useful if you want a user in two lobbies, for example matching groups together + // a user can be in only one regular lobby, and up to two invisible lobbies + k_ELobbyTypePrivateUnique = 4, // private, unique and does not delete when empty - only one of these may exist per unique keypair set + // can only create from webapi +}; + +// lobby search filter tools +enum ELobbyComparison +{ + k_ELobbyComparisonEqualToOrLessThan = -2, + k_ELobbyComparisonLessThan = -1, + k_ELobbyComparisonEqual = 0, + k_ELobbyComparisonGreaterThan = 1, + k_ELobbyComparisonEqualToOrGreaterThan = 2, + k_ELobbyComparisonNotEqual = 3, +}; + +// lobby search distance. Lobby results are sorted from closest to farthest. +enum ELobbyDistanceFilter +{ + k_ELobbyDistanceFilterClose, // only lobbies in the same immediate region will be returned + k_ELobbyDistanceFilterDefault, // only lobbies in the same region or near by regions + k_ELobbyDistanceFilterFar, // for games that don't have many latency requirements, will return lobbies about half-way around the globe + k_ELobbyDistanceFilterWorldwide, // no filtering, will match lobbies as far as India to NY (not recommended, expect multiple seconds of latency between the clients) +}; + +// maximum number of characters a lobby metadata key can be +#define k_nMaxLobbyKeyLength 255 + +//----------------------------------------------------------------------------- +// Purpose: Functions for match making services for clients to get to favorites +// and to operate on game lobbies. +//----------------------------------------------------------------------------- +class ISteamMatchmaking +{ +public: + // game server favorites storage + // saves basic details about a multiplayer game server locally + + // returns the number of favorites servers the user has stored + virtual int GetFavoriteGameCount() = 0; + + // returns the details of the game server + // iGame is of range [0,GetFavoriteGameCount()) + // *pnIP, *pnConnPort are filled in the with IP:port of the game server + // *punFlags specify whether the game server was stored as an explicit favorite or in the history of connections + // *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added + virtual bool GetFavoriteGame( int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer ) = 0; + + // adds the game server to the local list; updates the time played of the server if it already exists in the list + virtual int AddFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) = 0; + + // removes the game server from the local storage; returns true if one was removed + virtual bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ) = 0; + + /////// + // Game lobby functions + + // Get a list of relevant lobbies + // this is an asynchronous request + // results will be returned by LobbyMatchList_t callback & call result, with the number of lobbies found + // this will never return lobbies that are full + // to add more filter, the filter calls below need to be call before each and every RequestLobbyList() call + // use the CCallResult<> object in steam_api.h to match the SteamAPICall_t call result to a function in an object, e.g. + /* + class CMyLobbyListManager + { + CCallResult m_CallResultLobbyMatchList; + void FindLobbies() + { + // SteamMatchmaking()->AddRequestLobbyListFilter*() functions would be called here, before RequestLobbyList() + SteamAPICall_t hSteamAPICall = SteamMatchmaking()->RequestLobbyList(); + m_CallResultLobbyMatchList.Set( hSteamAPICall, this, &CMyLobbyListManager::OnLobbyMatchList ); + } + + void OnLobbyMatchList( LobbyMatchList_t *pLobbyMatchList, bool bIOFailure ) + { + // lobby list has be retrieved from Steam back-end, use results + } + } + */ + // + STEAM_CALL_RESULT( LobbyMatchList_t ) + virtual SteamAPICall_t RequestLobbyList() = 0; + // filters for lobbies + // this needs to be called before RequestLobbyList() to take effect + // these are cleared on each call to RequestLobbyList() + virtual void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType ) = 0; + // numerical comparison + virtual void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType ) = 0; + // returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence + virtual void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueToBeCloseTo ) = 0; + // returns only lobbies with the specified number of slots available + virtual void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable ) = 0; + // sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed) + virtual void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilter ) = 0; + // sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client + virtual void AddRequestLobbyListResultCountFilter( int cMaxResults ) = 0; + + virtual void AddRequestLobbyListCompatibleMembersFilter( CSteamID steamIDLobby ) = 0; + + // returns the CSteamID of a lobby, as retrieved by a RequestLobbyList call + // should only be called after a LobbyMatchList_t callback is received + // iLobby is of the range [0, LobbyMatchList_t::m_nLobbiesMatching) + // the returned CSteamID::IsValid() will be false if iLobby is out of range + virtual CSteamID GetLobbyByIndex( int iLobby ) = 0; + + // Create a lobby on the Steam servers. + // If private, then the lobby will not be returned by any RequestLobbyList() call; the CSteamID + // of the lobby will need to be communicated via game channels or via InviteUserToLobby() + // this is an asynchronous request + // results will be returned by LobbyCreated_t callback and call result; lobby is joined & ready to use at this point + // a LobbyEnter_t callback will also be received (since the local user is joining their own lobby) + STEAM_CALL_RESULT( LobbyCreated_t ) + virtual SteamAPICall_t CreateLobby( ELobbyType eLobbyType, int cMaxMembers ) = 0; + + // Joins an existing lobby + // this is an asynchronous request + // results will be returned by LobbyEnter_t callback & call result, check m_EChatRoomEnterResponse to see if was successful + // lobby metadata is available to use immediately on this call completing + STEAM_CALL_RESULT( LobbyEnter_t ) + virtual SteamAPICall_t JoinLobby( CSteamID steamIDLobby ) = 0; + + // Leave a lobby; this will take effect immediately on the client side + // other users in the lobby will be notified by a LobbyChatUpdate_t callback + virtual void LeaveLobby( CSteamID steamIDLobby ) = 0; + + // Invite another user to the lobby + // the target user will receive a LobbyInvite_t callback + // will return true if the invite is successfully sent, whether or not the target responds + // returns false if the local user is not connected to the Steam servers + // if the other user clicks the join link, a GameLobbyJoinRequested_t will be posted if the user is in-game, + // or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id> + virtual bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee ) = 0; + + // Lobby iteration, for viewing details of users in a lobby + // only accessible if the lobby user is a member of the specified lobby + // persona information for other lobby members (name, avatar, etc.) will be asynchronously received + // and accessible via ISteamFriends interface + + // returns the number of users in the specified lobby + virtual int GetNumLobbyMembers( CSteamID steamIDLobby ) = 0; + // returns the CSteamID of a user in the lobby + // iMember is of range [0,GetNumLobbyMembers()) + // note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby + virtual CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember ) = 0; + + // Get data associated with this lobby + // takes a simple key, and returns the string associated with it + // "" will be returned if no value is set, or if steamIDLobby is invalid + virtual const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey ) = 0; + // Sets a key/value pair in the lobby metadata + // each user in the lobby will be broadcast this new value, and any new users joining will receive any existing data + // this can be used to set lobby names, map, etc. + // to reset a key, just set it to "" + // other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback + virtual bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0; + + // returns the number of metadata keys set on the specified lobby + virtual int GetLobbyDataCount( CSteamID steamIDLobby ) = 0; + + // returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount()) + virtual bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize ) = 0; + + // removes a metadata key from the lobby + virtual bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey ) = 0; + + // Gets per-user metadata for someone in this lobby + virtual const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey ) = 0; + // Sets per-user metadata (for the local user implicitly) + virtual void SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0; + + // Broadcasts a chat message to the all the users in the lobby + // users in the lobby (including the local user) will receive a LobbyChatMsg_t callback + // returns true if the message is successfully sent + // pvMsgBody can be binary or text data, up to 4k + // if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator + virtual bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody ) = 0; + // Get a chat message as specified in a LobbyChatMsg_t callback + // iChatID is the LobbyChatMsg_t::m_iChatID value in the callback + // *pSteamIDUser is filled in with the CSteamID of the member + // *pvData is filled in with the message itself + // return value is the number of bytes written into the buffer + virtual int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, STEAM_OUT_STRUCT() CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0; + + // Refreshes metadata for a lobby you're not necessarily in right now + // you never do this for lobbies you're a member of, only if your + // this will send down all the metadata associated with a lobby + // this is an asynchronous call + // returns false if the local user is not connected to the Steam servers + // results will be returned by a LobbyDataUpdate_t callback + // if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false + virtual bool RequestLobbyData( CSteamID steamIDLobby ) = 0; + + // sets the game server associated with the lobby + // usually at this point, the users will join the specified game server + // either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect + virtual void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer ) = 0; + // returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist + virtual bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, STEAM_OUT_STRUCT() CSteamID *psteamIDGameServer ) = 0; + + // set the limit on the # of users who can join the lobby + virtual bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers ) = 0; + // returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined + virtual int GetLobbyMemberLimit( CSteamID steamIDLobby ) = 0; + + // updates which type of lobby it is + // only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls + virtual bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType ) = 0; + + // sets whether or not a lobby is joinable - defaults to true for a new lobby + // if set to false, no user can join, even if they are a friend or have been invited + virtual bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable ) = 0; + + // returns the current lobby owner + // you must be a member of the lobby to access this + // there always one lobby owner - if the current owner leaves, another user will become the owner + // it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner + virtual CSteamID GetLobbyOwner( CSteamID steamIDLobby ) = 0; + + // changes who the lobby owner is + // you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby + // after completion, the local user will no longer be the owner + virtual bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner ) = 0; + + // link two lobbies for the purposes of checking player compatibility + // you must be the lobby owner of both lobbies + virtual bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobbyDependent ) = 0; + +#ifdef _PS3 + // changes who the lobby owner is + // you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby + // after completion, the local user will no longer be the owner + virtual void CheckForPSNGameBootInvite( unsigned int iGameBootAttributes ) = 0; +#endif +}; +#define STEAMMATCHMAKING_INTERFACE_VERSION "SteamMatchMaking009" + +// Global interface accessor +inline ISteamMatchmaking *SteamMatchmaking(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMatchmaking *, SteamMatchmaking, STEAMMATCHMAKING_INTERFACE_VERSION ); + +//----------------------------------------------------------------------------- +// Callback interfaces for server list functions (see ISteamMatchmakingServers below) +// +// The idea here is that your game code implements objects that implement these +// interfaces to receive callback notifications after calling asynchronous functions +// inside the ISteamMatchmakingServers() interface below. +// +// This is different than normal Steam callback handling due to the potentially +// large size of server lists. +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// Typedef for handle type you will receive when requesting server list. +//----------------------------------------------------------------------------- +typedef void* HServerListRequest; + +//----------------------------------------------------------------------------- +// Purpose: Callback interface for receiving responses after a server list refresh +// or an individual server update. +// +// Since you get these callbacks after requesting full list refreshes you will +// usually implement this interface inside an object like CServerBrowser. If that +// object is getting destructed you should use ISteamMatchMakingServers()->CancelQuery() +// to cancel any in-progress queries so you don't get a callback into the destructed +// object and crash. +//----------------------------------------------------------------------------- +class ISteamMatchmakingServerListResponse +{ +public: + // Server has responded ok with updated data + virtual void ServerResponded( HServerListRequest hRequest, int iServer ) = 0; + + // Server has failed to respond + virtual void ServerFailedToRespond( HServerListRequest hRequest, int iServer ) = 0; + + // A list refresh you had initiated is now 100% completed + virtual void RefreshComplete( HServerListRequest hRequest, EMatchMakingServerResponse response ) = 0; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Callback interface for receiving responses after pinging an individual server +// +// These callbacks all occur in response to querying an individual server +// via the ISteamMatchmakingServers()->PingServer() call below. If you are +// destructing an object that implements this interface then you should call +// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query +// which is in progress. Failure to cancel in progress queries when destructing +// a callback handler may result in a crash when a callback later occurs. +//----------------------------------------------------------------------------- +class ISteamMatchmakingPingResponse +{ +public: + // Server has responded successfully and has updated data + virtual void ServerResponded( gameserveritem_t &server ) = 0; + + // Server failed to respond to the ping request + virtual void ServerFailedToRespond() = 0; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Callback interface for receiving responses after requesting details on +// who is playing on a particular server. +// +// These callbacks all occur in response to querying an individual server +// via the ISteamMatchmakingServers()->PlayerDetails() call below. If you are +// destructing an object that implements this interface then you should call +// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query +// which is in progress. Failure to cancel in progress queries when destructing +// a callback handler may result in a crash when a callback later occurs. +//----------------------------------------------------------------------------- +class ISteamMatchmakingPlayersResponse +{ +public: + // Got data on a new player on the server -- you'll get this callback once per player + // on the server which you have requested player data on. + virtual void AddPlayerToList( const char *pchName, int nScore, float flTimePlayed ) = 0; + + // The server failed to respond to the request for player details + virtual void PlayersFailedToRespond() = 0; + + // The server has finished responding to the player details request + // (ie, you won't get anymore AddPlayerToList callbacks) + virtual void PlayersRefreshComplete() = 0; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Callback interface for receiving responses after requesting rules +// details on a particular server. +// +// These callbacks all occur in response to querying an individual server +// via the ISteamMatchmakingServers()->ServerRules() call below. If you are +// destructing an object that implements this interface then you should call +// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query +// which is in progress. Failure to cancel in progress queries when destructing +// a callback handler may result in a crash when a callback later occurs. +//----------------------------------------------------------------------------- +class ISteamMatchmakingRulesResponse +{ +public: + // Got data on a rule on the server -- you'll get one of these per rule defined on + // the server you are querying + virtual void RulesResponded( const char *pchRule, const char *pchValue ) = 0; + + // The server failed to respond to the request for rule details + virtual void RulesFailedToRespond() = 0; + + // The server has finished responding to the rule details request + // (ie, you won't get anymore RulesResponded callbacks) + virtual void RulesRefreshComplete() = 0; +}; + + +//----------------------------------------------------------------------------- +// Typedef for handle type you will receive when querying details on an individual server. +//----------------------------------------------------------------------------- +typedef int HServerQuery; +const int HSERVERQUERY_INVALID = 0xffffffff; + +//----------------------------------------------------------------------------- +// Purpose: Functions for match making services for clients to get to game lists and details +//----------------------------------------------------------------------------- +class ISteamMatchmakingServers +{ +public: + // Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values. + // Each call allocates a new asynchronous request object. + // Request object must be released by calling ReleaseRequest( hServerListRequest ) + virtual HServerListRequest RequestInternetServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + virtual HServerListRequest RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + virtual HServerListRequest RequestFriendsServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + virtual HServerListRequest RequestFavoritesServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + virtual HServerListRequest RequestHistoryServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + virtual HServerListRequest RequestSpectatorServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0; + + // Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress. + // RefreshComplete callback is not posted when request is released. + virtual void ReleaseRequest( HServerListRequest hServerListRequest ) = 0; + + /* the filter operation codes that go in the key part of MatchMakingKeyValuePair_t should be one of these: + + "map" + - Server passes the filter if the server is playing the specified map. + "gamedataand" + - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains all of the + specified strings. The value field is a comma-delimited list of strings to match. + "gamedataor" + - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains at least one of the + specified strings. The value field is a comma-delimited list of strings to match. + "gamedatanor" + - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) does not contain any + of the specified strings. The value field is a comma-delimited list of strings to check. + "gametagsand" + - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) contains all + of the specified strings. The value field is a comma-delimited list of strings to check. + "gametagsnor" + - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) does not contain any + of the specified strings. The value field is a comma-delimited list of strings to check. + "and" (x1 && x2 && ... && xn) + "or" (x1 || x2 || ... || xn) + "nand" !(x1 && x2 && ... && xn) + "nor" !(x1 || x2 || ... || xn) + - Performs Boolean operation on the following filters. The operand to this filter specifies + the "size" of the Boolean inputs to the operation, in Key/value pairs. (The keyvalue + pairs must immediately follow, i.e. this is a prefix logical operator notation.) + In the simplest case where Boolean expressions are not nested, this is simply + the number of operands. + + For example, to match servers on a particular map or with a particular tag, would would + use these filters. + + ( server.map == "cp_dustbowl" || server.gametags.contains("payload") ) + "or", "2" + "map", "cp_dustbowl" + "gametagsand", "payload" + + If logical inputs are nested, then the operand specifies the size of the entire + "length" of its operands, not the number of immediate children. + + ( server.map == "cp_dustbowl" || ( server.gametags.contains("payload") && !server.gametags.contains("payloadrace") ) ) + "or", "4" + "map", "cp_dustbowl" + "and", "2" + "gametagsand", "payload" + "gametagsnor", "payloadrace" + + Unary NOT can be achieved using either "nand" or "nor" with a single operand. + + "addr" + - Server passes the filter if the server's query address matches the specified IP or IP:port. + "gameaddr" + - Server passes the filter if the server's game address matches the specified IP or IP:port. + + The following filter operations ignore the "value" part of MatchMakingKeyValuePair_t + + "dedicated" + - Server passes the filter if it passed true to SetDedicatedServer. + "secure" + - Server passes the filter if the server is VAC-enabled. + "notfull" + - Server passes the filter if the player count is less than the reported max player count. + "hasplayers" + - Server passes the filter if the player count is greater than zero. + "noplayers" + - Server passes the filter if it doesn't have any players. + "linux" + - Server passes the filter if it's a linux server + */ + + // Get details on a given server in the list, you can get the valid range of index + // values by calling GetServerCount(). You will also receive index values in + // ISteamMatchmakingServerListResponse::ServerResponded() callbacks + virtual gameserveritem_t *GetServerDetails( HServerListRequest hRequest, int iServer ) = 0; + + // Cancel an request which is operation on the given list type. You should call this to cancel + // any in-progress requests before destructing a callback object that may have been passed + // to one of the above list request calls. Not doing so may result in a crash when a callback + // occurs on the destructed object. + // Canceling a query does not release the allocated request handle. + // The request handle must be released using ReleaseRequest( hRequest ) + virtual void CancelQuery( HServerListRequest hRequest ) = 0; + + // Ping every server in your list again but don't update the list of servers + // Query callback installed when the server list was requested will be used + // again to post notifications and RefreshComplete, so the callback must remain + // valid until another RefreshComplete is called on it or the request + // is released with ReleaseRequest( hRequest ) + virtual void RefreshQuery( HServerListRequest hRequest ) = 0; + + // Returns true if the list is currently refreshing its server list + virtual bool IsRefreshing( HServerListRequest hRequest ) = 0; + + // How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1 + virtual int GetServerCount( HServerListRequest hRequest ) = 0; + + // Refresh a single server inside of a query (rather than all the servers ) + virtual void RefreshServer( HServerListRequest hRequest, int iServer ) = 0; + + + //----------------------------------------------------------------------------- + // Queries to individual servers directly via IP/Port + //----------------------------------------------------------------------------- + + // Request updated ping time and other details from a single server + virtual HServerQuery PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse ) = 0; + + // Request the list of players currently playing on a server + virtual HServerQuery PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse ) = 0; + + // Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side) + virtual HServerQuery ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse ) = 0; + + // Cancel an outstanding Ping/Players/Rules query from above. You should call this to cancel + // any in-progress requests before destructing a callback object that may have been passed + // to one of the above calls to avoid crashing when callbacks occur. + virtual void CancelServerQuery( HServerQuery hServerQuery ) = 0; +}; +#define STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "SteamMatchMakingServers002" + +// Global interface accessor +inline ISteamMatchmakingServers *SteamMatchmakingServers(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMatchmakingServers *, SteamMatchmakingServers, STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION ); + +// game server flags +const uint32 k_unFavoriteFlagNone = 0x00; +const uint32 k_unFavoriteFlagFavorite = 0x01; // this game favorite entry is for the favorites list +const uint32 k_unFavoriteFlagHistory = 0x02; // this game favorite entry is for the history list + + +//----------------------------------------------------------------------------- +// Purpose: Used in ChatInfo messages - fields specific to a chat member - must fit in a uint32 +//----------------------------------------------------------------------------- +enum EChatMemberStateChange +{ + // Specific to joining / leaving the chatroom + k_EChatMemberStateChangeEntered = 0x0001, // This user has joined or is joining the chat room + k_EChatMemberStateChangeLeft = 0x0002, // This user has left or is leaving the chat room + k_EChatMemberStateChangeDisconnected = 0x0004, // User disconnected without leaving the chat first + k_EChatMemberStateChangeKicked = 0x0008, // User kicked + k_EChatMemberStateChangeBanned = 0x0010, // User kicked and banned +}; + +// returns true of the flags indicate that a user has been removed from the chat +#define BChatMemberStateChangeRemoved( rgfChatMemberStateChangeFlags ) ( rgfChatMemberStateChangeFlags & ( k_EChatMemberStateChangeDisconnected | k_EChatMemberStateChangeLeft | k_EChatMemberStateChangeKicked | k_EChatMemberStateChangeBanned ) ) + + + +//----------------------------------------------------------------------------- +// Purpose: Functions for match making services for clients to get to favorites +// and to operate on game lobbies. +//----------------------------------------------------------------------------- +class ISteamGameSearch +{ +public: + // ============================================================================================= + // Game Player APIs + + // a keyname and a list of comma separated values: one of which is must be found in order for the match to qualify + // fails if a search is currently in progress + virtual EGameSearchErrorCode_t AddGameSearchParams( const char *pchKeyToFind, const char *pchValuesToFind ) = 0; + + // all players in lobby enter the queue and await a SearchForGameNotificationCallback_t callback. fails if another search is currently in progress + // if not the owner of the lobby or search already in progress this call fails + // periodic callbacks will be sent as queue time estimates change + virtual EGameSearchErrorCode_t SearchForGameWithLobby( CSteamID steamIDLobby, int nPlayerMin, int nPlayerMax ) = 0; + + // user enter the queue and await a SearchForGameNotificationCallback_t callback. fails if another search is currently in progress + // periodic callbacks will be sent as queue time estimates change + virtual EGameSearchErrorCode_t SearchForGameSolo( int nPlayerMin, int nPlayerMax ) = 0; + + // after receiving SearchForGameResultCallback_t, accept or decline the game + // multiple SearchForGameResultCallback_t will follow as players accept game until the host starts or cancels the game + virtual EGameSearchErrorCode_t AcceptGame() = 0; + virtual EGameSearchErrorCode_t DeclineGame() = 0; + + // after receiving GameStartedByHostCallback_t get connection details to server + virtual EGameSearchErrorCode_t RetrieveConnectionDetails( CSteamID steamIDHost, char *pchConnectionDetails, int cubConnectionDetails ) = 0; + + // leaves queue if still waiting + virtual EGameSearchErrorCode_t EndGameSearch() = 0; + + // ============================================================================================= + // Game Host APIs + + // a keyname and a list of comma separated values: all the values you allow + virtual EGameSearchErrorCode_t SetGameHostParams( const char *pchKey, const char *pchValue ) = 0; + + // set connection details for players once game is found so they can connect to this server + virtual EGameSearchErrorCode_t SetConnectionDetails( const char *pchConnectionDetails, int cubConnectionDetails ) = 0; + + // mark server as available for more players with nPlayerMin,nPlayerMax desired + // accept no lobbies with playercount greater than nMaxTeamSize + // the set of lobbies returned must be partitionable into teams of no more than nMaxTeamSize + // RequestPlayersForGameNotificationCallback_t callback will be sent when the search has started + // multple RequestPlayersForGameResultCallback_t callbacks will follow when players are found + virtual EGameSearchErrorCode_t RequestPlayersForGame( int nPlayerMin, int nPlayerMax, int nMaxTeamSize ) = 0; + + // accept the player list and release connection details to players + // players will only be given connection details and host steamid when this is called + // ( allows host to accept after all players confirm, some confirm, or none confirm. decision is entirely up to the host ) + virtual EGameSearchErrorCode_t HostConfirmGameStart( uint64 ullUniqueGameID ) = 0; + + // cancel request and leave the pool of game hosts looking for players + // if a set of players has already been sent to host, all players will receive SearchForGameHostFailedToConfirm_t + virtual EGameSearchErrorCode_t CancelRequestPlayersForGame() = 0; + + // submit a result for one player. does not end the game. ullUniqueGameID continues to describe this game + virtual EGameSearchErrorCode_t SubmitPlayerResult( uint64 ullUniqueGameID, CSteamID steamIDPlayer, EPlayerResult_t EPlayerResult ) = 0; + + // ends the game. no further SubmitPlayerResults for ullUniqueGameID will be accepted + // any future requests will provide a new ullUniqueGameID + virtual EGameSearchErrorCode_t EndGame( uint64 ullUniqueGameID ) = 0; + +}; +#define STEAMGAMESEARCH_INTERFACE_VERSION "SteamMatchGameSearch001" + +// Global interface accessor +inline ISteamGameSearch *SteamGameSearch(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamGameSearch *, SteamGameSearch, STEAMGAMESEARCH_INTERFACE_VERSION ); + + +//----------------------------------------------------------------------------- +// Purpose: Functions for quickly creating a Party with friends or acquaintances, +// EG from chat rooms. +//----------------------------------------------------------------------------- +enum ESteamPartyBeaconLocationType +{ + k_ESteamPartyBeaconLocationType_Invalid = 0, + k_ESteamPartyBeaconLocationType_ChatGroup = 1, + + k_ESteamPartyBeaconLocationType_Max, +}; + + +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +struct SteamPartyBeaconLocation_t +{ + ESteamPartyBeaconLocationType m_eType; + uint64 m_ulLocationID; +}; + +enum ESteamPartyBeaconLocationData +{ + k_ESteamPartyBeaconLocationDataInvalid = 0, + k_ESteamPartyBeaconLocationDataName = 1, + k_ESteamPartyBeaconLocationDataIconURLSmall = 2, + k_ESteamPartyBeaconLocationDataIconURLMedium = 3, + k_ESteamPartyBeaconLocationDataIconURLLarge = 4, +}; + +class ISteamParties +{ +public: + + // ============================================================================================= + // Party Client APIs + + // Enumerate any active beacons for parties you may wish to join + virtual uint32 GetNumActiveBeacons() = 0; + virtual PartyBeaconID_t GetBeaconByIndex( uint32 unIndex ) = 0; + virtual bool GetBeaconDetails( PartyBeaconID_t ulBeaconID, CSteamID *pSteamIDBeaconOwner, STEAM_OUT_STRUCT() SteamPartyBeaconLocation_t *pLocation, STEAM_OUT_STRING_COUNT(cchMetadata) char *pchMetadata, int cchMetadata ) = 0; + + // Join an open party. Steam will reserve one beacon slot for your SteamID, + // and return the necessary JoinGame string for you to use to connect + STEAM_CALL_RESULT( JoinPartyCallback_t ) + virtual SteamAPICall_t JoinParty( PartyBeaconID_t ulBeaconID ) = 0; + + // ============================================================================================= + // Party Host APIs + + // Get a list of possible beacon locations + virtual bool GetNumAvailableBeaconLocations( uint32 *puNumLocations ) = 0; + virtual bool GetAvailableBeaconLocations( SteamPartyBeaconLocation_t *pLocationList, uint32 uMaxNumLocations ) = 0; + + // Create a new party beacon and activate it in the selected location. + // unOpenSlots is the maximum number of users that Steam will send to you. + // When people begin responding to your beacon, Steam will send you + // PartyReservationCallback_t callbacks to let you know who is on the way. + STEAM_CALL_RESULT( CreateBeaconCallback_t ) + virtual SteamAPICall_t CreateBeacon( uint32 unOpenSlots, SteamPartyBeaconLocation_t *pBeaconLocation, const char *pchConnectString, const char *pchMetadata ) = 0; + + // Call this function when a user that had a reservation (see callback below) + // has successfully joined your party. + // Steam will manage the remaining open slots automatically. + virtual void OnReservationCompleted( PartyBeaconID_t ulBeacon, CSteamID steamIDUser ) = 0; + + // To cancel a reservation (due to timeout or user input), call this. + // Steam will open a new reservation slot. + // Note: The user may already be in-flight to your game, so it's possible they will still connect and try to join your party. + virtual void CancelReservation( PartyBeaconID_t ulBeacon, CSteamID steamIDUser ) = 0; + + // Change the number of open beacon reservation slots. + // Call this if, for example, someone without a reservation joins your party (eg a friend, or via your own matchmaking system). + STEAM_CALL_RESULT( ChangeNumOpenSlotsCallback_t ) + virtual SteamAPICall_t ChangeNumOpenSlots( PartyBeaconID_t ulBeacon, uint32 unOpenSlots ) = 0; + + // Turn off the beacon. + virtual bool DestroyBeacon( PartyBeaconID_t ulBeacon ) = 0; + + // Utils + virtual bool GetBeaconLocationData( SteamPartyBeaconLocation_t BeaconLocation, ESteamPartyBeaconLocationData eData, STEAM_OUT_STRING_COUNT(cchDataStringOut) char *pchDataStringOut, int cchDataStringOut ) = 0; + +}; +#define STEAMPARTIES_INTERFACE_VERSION "SteamParties002" + +// Global interface accessor +inline ISteamParties *SteamParties(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamParties *, SteamParties, STEAMPARTIES_INTERFACE_VERSION ); + + +//----------------------------------------------------------------------------- +// Callbacks for ISteamMatchmaking (which go through the regular Steam callback registration system) + +//----------------------------------------------------------------------------- +// Purpose: a server was added/removed from the favorites list, you should refresh now +//----------------------------------------------------------------------------- +struct FavoritesListChanged_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 2 }; + uint32 m_nIP; // an IP of 0 means reload the whole list, any other value means just one server + uint32 m_nQueryPort; + uint32 m_nConnPort; + uint32 m_nAppID; + uint32 m_nFlags; + bool m_bAdd; // true if this is adding the entry, otherwise it is a remove + AccountID_t m_unAccountId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Someone has invited you to join a Lobby +// normally you don't need to do anything with this, since +// the Steam UI will also display a ' has invited you to the lobby, join?' dialog +// +// if the user outside a game chooses to join, your game will be launched with the parameter "+connect_lobby <64-bit lobby id>", +// or with the callback GameLobbyJoinRequested_t if they're already in-game +//----------------------------------------------------------------------------- +struct LobbyInvite_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 3 }; + + uint64 m_ulSteamIDUser; // Steam ID of the person making the invite + uint64 m_ulSteamIDLobby; // Steam ID of the Lobby + uint64 m_ulGameID; // GameID of the Lobby +}; + + +//----------------------------------------------------------------------------- +// Purpose: Sent on entering a lobby, or on failing to enter +// m_EChatRoomEnterResponse will be set to k_EChatRoomEnterResponseSuccess on success, +// or a higher value on failure (see enum EChatRoomEnterResponse) +//----------------------------------------------------------------------------- +struct LobbyEnter_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 4 }; + + uint64 m_ulSteamIDLobby; // SteamID of the Lobby you have entered + uint32 m_rgfChatPermissions; // Permissions of the current user + bool m_bLocked; // If true, then only invited users may join + uint32 m_EChatRoomEnterResponse; // EChatRoomEnterResponse +}; + + +//----------------------------------------------------------------------------- +// Purpose: The lobby metadata has changed +// if m_ulSteamIDMember is the steamID of a lobby member, use GetLobbyMemberData() to access per-user details +// if m_ulSteamIDMember == m_ulSteamIDLobby, use GetLobbyData() to access lobby metadata +//----------------------------------------------------------------------------- +struct LobbyDataUpdate_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 5 }; + + uint64 m_ulSteamIDLobby; // steamID of the Lobby + uint64 m_ulSteamIDMember; // steamID of the member whose data changed, or the room itself + uint8 m_bSuccess; // true if we lobby data was successfully changed; + // will only be false if RequestLobbyData() was called on a lobby that no longer exists +}; + + +//----------------------------------------------------------------------------- +// Purpose: The lobby chat room state has changed +// this is usually sent when a user has joined or left the lobby +//----------------------------------------------------------------------------- +struct LobbyChatUpdate_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 6 }; + + uint64 m_ulSteamIDLobby; // Lobby ID + uint64 m_ulSteamIDUserChanged; // user who's status in the lobby just changed - can be recipient + uint64 m_ulSteamIDMakingChange; // Chat member who made the change (different from SteamIDUserChange if kicking, muting, etc.) + // for example, if one user kicks another from the lobby, this will be set to the id of the user who initiated the kick + uint32 m_rgfChatMemberStateChange; // bitfield of EChatMemberStateChange values +}; + + +//----------------------------------------------------------------------------- +// Purpose: A chat message for this lobby has been sent +// use GetLobbyChatEntry( m_iChatID ) to retrieve the contents of this message +//----------------------------------------------------------------------------- +struct LobbyChatMsg_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 7 }; + + uint64 m_ulSteamIDLobby; // the lobby id this is in + uint64 m_ulSteamIDUser; // steamID of the user who has sent this message + uint8 m_eChatEntryType; // type of message + uint32 m_iChatID; // index of the chat entry to lookup +}; + + +//----------------------------------------------------------------------------- +// Purpose: A game created a game for all the members of the lobby to join, +// as triggered by a SetLobbyGameServer() +// it's up to the individual clients to take action on this; the usual +// game behavior is to leave the lobby and connect to the specified game server +//----------------------------------------------------------------------------- +struct LobbyGameCreated_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 9 }; + + uint64 m_ulSteamIDLobby; // the lobby we were in + uint64 m_ulSteamIDGameServer; // the new game server that has been created or found for the lobby members + uint32 m_unIP; // IP & Port of the game server (if any) + uint16 m_usPort; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Number of matching lobbies found +// iterate the returned lobbies with GetLobbyByIndex(), from values 0 to m_nLobbiesMatching-1 +//----------------------------------------------------------------------------- +struct LobbyMatchList_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 10 }; + uint32 m_nLobbiesMatching; // Number of lobbies that matched search criteria and we have SteamIDs for +}; + + +//----------------------------------------------------------------------------- +// Purpose: posted if a user is forcefully removed from a lobby +// can occur if a user loses connection to Steam +//----------------------------------------------------------------------------- +struct LobbyKicked_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 12 }; + uint64 m_ulSteamIDLobby; // Lobby + uint64 m_ulSteamIDAdmin; // User who kicked you - possibly the ID of the lobby itself + uint8 m_bKickedDueToDisconnect; // true if you were kicked from the lobby due to the user losing connection to Steam (currently always true) +}; + + +//----------------------------------------------------------------------------- +// Purpose: Result of our request to create a Lobby +// m_eResult == k_EResultOK on success +// at this point, the lobby has been joined and is ready for use +// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby) +//----------------------------------------------------------------------------- +struct LobbyCreated_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 13 }; + + EResult m_eResult; // k_EResultOK - the lobby was successfully created + // k_EResultNoConnection - your Steam client doesn't have a connection to the back-end + // k_EResultTimeout - you the message to the Steam servers, but it didn't respond + // k_EResultFail - the server responded, but with an unknown internal error + // k_EResultAccessDenied - your game isn't set to allow lobbies, or your client does haven't rights to play the game + // k_EResultLimitExceeded - your game client has created too many lobbies + + uint64 m_ulSteamIDLobby; // chat room, zero if failed +}; + +// used by now obsolete RequestFriendsLobbiesResponse_t +// enum { k_iCallback = k_iSteamMatchmakingCallbacks + 14 }; + + +//----------------------------------------------------------------------------- +// Purpose: Result of CheckForPSNGameBootInvite +// m_eResult == k_EResultOK on success +// at this point, the local user may not have finishing joining this lobby; +// game code should wait until the subsequent LobbyEnter_t callback is received +//----------------------------------------------------------------------------- +struct PSNGameBootInviteResult_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 15 }; + + bool m_bGameBootInviteExists; + CSteamID m_steamIDLobby; // Should be valid if m_bGameBootInviteExists == true +}; + + +//----------------------------------------------------------------------------- +// Purpose: Result of our request to create a Lobby +// m_eResult == k_EResultOK on success +// at this point, the lobby has been joined and is ready for use +// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby) +//----------------------------------------------------------------------------- +struct FavoritesListAccountsUpdated_t +{ + enum { k_iCallback = k_iSteamMatchmakingCallbacks + 16 }; + + EResult m_eResult; +}; + + + +//----------------------------------------------------------------------------- +// Callbacks for ISteamGameSearch (which go through the regular Steam callback registration system) + +struct SearchForGameProgressCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 1 }; + + uint64 m_ullSearchID; // all future callbacks referencing this search will include this Search ID + + EResult m_eResult; // if search has started this result will be k_EResultOK, any other value indicates search has failed to start or has terminated + CSteamID m_lobbyID; // lobby ID if lobby search, invalid steamID otherwise + CSteamID m_steamIDEndedSearch; // if search was terminated, steamID that terminated search + + int32 m_nSecondsRemainingEstimate; + int32 m_cPlayersSearching; +}; + +// notification to all players searching that a game has been found +struct SearchForGameResultCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 2 }; + + uint64 m_ullSearchID; + + EResult m_eResult; // if game/host was lost this will be an error value + + // if m_bGameFound is true the following are non-zero + int32 m_nCountPlayersInGame; + int32 m_nCountAcceptedGame; + // if m_steamIDHost is valid the host has started the game + CSteamID m_steamIDHost; + bool m_bFinalCallback; +}; + + +//----------------------------------------------------------------------------- +// ISteamGameSearch : Game Host API callbacks + +// callback from RequestPlayersForGame when the matchmaking service has started or ended search +// callback will also follow a call from CancelRequestPlayersForGame - m_bSearchInProgress will be false +struct RequestPlayersForGameProgressCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 11 }; + + EResult m_eResult; // m_ullSearchID will be non-zero if this is k_EResultOK + uint64 m_ullSearchID; // all future callbacks referencing this search will include this Search ID +}; + +// callback from RequestPlayersForGame +// one of these will be sent per player +// followed by additional callbacks when players accept or decline the game +struct RequestPlayersForGameResultCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 12 }; + + EResult m_eResult; // m_ullSearchID will be non-zero if this is k_EResultOK + uint64 m_ullSearchID; + + CSteamID m_SteamIDPlayerFound; // player steamID + CSteamID m_SteamIDLobby; // if the player is in a lobby, the lobby ID + enum PlayerAcceptState_t + { + k_EStateUnknown = 0, + k_EStatePlayerAccepted = 1, + k_EStatePlayerDeclined = 2, + }; + PlayerAcceptState_t m_ePlayerAcceptState; + int32 m_nPlayerIndex; + int32 m_nTotalPlayersFound; // expect this many callbacks at minimum + int32 m_nTotalPlayersAcceptedGame; + int32 m_nSuggestedTeamIndex; + uint64 m_ullUniqueGameID; +}; + + +struct RequestPlayersForGameFinalResultCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 13 }; + + EResult m_eResult; + uint64 m_ullSearchID; + uint64 m_ullUniqueGameID; +}; + + + +// this callback confirms that results were received by the matchmaking service for this player +struct SubmitPlayerResultResultCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 14 }; + + EResult m_eResult; + uint64 ullUniqueGameID; + CSteamID steamIDPlayer; +}; + + +// this callback confirms that the game is recorded as complete on the matchmaking service +// the next call to RequestPlayersForGame will generate a new unique game ID +struct EndGameResultCallback_t +{ + enum { k_iCallback = k_iSteamGameSearchCallbacks + 15 }; + + EResult m_eResult; + uint64 ullUniqueGameID; +}; + + +// Steam has responded to the user request to join a party via the given Beacon ID. +// If successful, the connect string contains game-specific instructions to connect +// to the game with that party. +struct JoinPartyCallback_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 1 }; + + EResult m_eResult; + PartyBeaconID_t m_ulBeaconID; + CSteamID m_SteamIDBeaconOwner; + char m_rgchConnectString[256]; +}; + +// Response to CreateBeacon request. If successful, the beacon ID is provided. +struct CreateBeaconCallback_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 2 }; + + EResult m_eResult; + PartyBeaconID_t m_ulBeaconID; +}; + +// Someone has used the beacon to join your party - they are in-flight now +// and we've reserved one of the open slots for them. +// You should confirm when they join your party by calling OnReservationCompleted(). +// Otherwise, Steam may timeout their reservation eventually. +struct ReservationNotificationCallback_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 3 }; + + PartyBeaconID_t m_ulBeaconID; + CSteamID m_steamIDJoiner; +}; + +// Response to ChangeNumOpenSlots call +struct ChangeNumOpenSlotsCallback_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 4 }; + + EResult m_eResult; +}; + +// The list of possible Party beacon locations has changed +struct AvailableBeaconLocationsUpdated_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 5 }; +}; + +// The list of active beacons may have changed +struct ActiveBeaconsUpdated_t +{ + enum { k_iCallback = k_iSteamPartiesCallbacks + 6 }; +}; + + +#pragma pack( pop ) + + +#endif // ISTEAMMATCHMAKING diff --git a/lsteamclient/steamworks_sdk_160/isteammusic.h b/lsteamclient/steamworks_sdk_160/isteammusic.h new file mode 100644 index 0000000000..ffa49a0893 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteammusic.h @@ -0,0 +1,71 @@ +//============ Copyright (c) Valve Corporation, All rights reserved. ============ + +#ifndef ISTEAMMUSIC_H +#define ISTEAMMUSIC_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +enum AudioPlayback_Status +{ + AudioPlayback_Undefined = 0, + AudioPlayback_Playing = 1, + AudioPlayback_Paused = 2, + AudioPlayback_Idle = 3 +}; + + +//----------------------------------------------------------------------------- +// Purpose: Functions to control music playback in the steam client +//----------------------------------------------------------------------------- +class ISteamMusic +{ +public: + virtual bool BIsEnabled() = 0; + virtual bool BIsPlaying() = 0; + + virtual AudioPlayback_Status GetPlaybackStatus() = 0; + + virtual void Play() = 0; + virtual void Pause() = 0; + virtual void PlayPrevious() = 0; + virtual void PlayNext() = 0; + + // volume is between 0.0 and 1.0 + virtual void SetVolume( float flVolume ) = 0; + virtual float GetVolume() = 0; + +}; + +#define STEAMMUSIC_INTERFACE_VERSION "STEAMMUSIC_INTERFACE_VERSION001" + +// Global interface accessor +inline ISteamMusic *SteamMusic(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusic *, SteamMusic, STEAMMUSIC_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +STEAM_CALLBACK_BEGIN( PlaybackStatusHasChanged_t, k_iSteamMusicCallbacks + 1 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( VolumeHasChanged_t, k_iSteamMusicCallbacks + 2 ) + STEAM_CALLBACK_MEMBER( 0, float, m_flNewVolume ) +STEAM_CALLBACK_END(1) + +#pragma pack( pop ) + + +#endif // #define ISTEAMMUSIC_H diff --git a/lsteamclient/steamworks_sdk_160/isteammusicremote.h b/lsteamclient/steamworks_sdk_160/isteammusicremote.h new file mode 100644 index 0000000000..a36f4f873f --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteammusicremote.h @@ -0,0 +1,133 @@ +//============ Copyright (c) Valve Corporation, All rights reserved. ============ + +#ifndef ISTEAMMUSICREMOTE_H +#define ISTEAMMUSICREMOTE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "isteammusic.h" + +#define k_SteamMusicNameMaxLength 255 +#define k_SteamMusicPNGMaxLength 65535 + + +class ISteamMusicRemote +{ +public: + // Service Definition + virtual bool RegisterSteamMusicRemote( const char *pchName ) = 0; + virtual bool DeregisterSteamMusicRemote() = 0; + virtual bool BIsCurrentMusicRemote() = 0; + virtual bool BActivationSuccess( bool bValue ) = 0; + + virtual bool SetDisplayName( const char *pchDisplayName ) = 0; + virtual bool SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength ) = 0; + + // Abilities for the user interface + virtual bool EnablePlayPrevious(bool bValue) = 0; + virtual bool EnablePlayNext( bool bValue ) = 0; + virtual bool EnableShuffled( bool bValue ) = 0; + virtual bool EnableLooped( bool bValue ) = 0; + virtual bool EnableQueue( bool bValue ) = 0; + virtual bool EnablePlaylists( bool bValue ) = 0; + + // Status + virtual bool UpdatePlaybackStatus( AudioPlayback_Status nStatus ) = 0; + virtual bool UpdateShuffled( bool bValue ) = 0; + virtual bool UpdateLooped( bool bValue ) = 0; + virtual bool UpdateVolume( float flValue ) = 0; // volume is between 0.0 and 1.0 + + // Current Entry + virtual bool CurrentEntryWillChange() = 0; + virtual bool CurrentEntryIsAvailable( bool bAvailable ) = 0; + virtual bool UpdateCurrentEntryText( const char *pchText ) = 0; + virtual bool UpdateCurrentEntryElapsedSeconds( int nValue ) = 0; + virtual bool UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength ) = 0; + virtual bool CurrentEntryDidChange() = 0; + + // Queue + virtual bool QueueWillChange() = 0; + virtual bool ResetQueueEntries() = 0; + virtual bool SetQueueEntry( int nID, int nPosition, const char *pchEntryText ) = 0; + virtual bool SetCurrentQueueEntry( int nID ) = 0; + virtual bool QueueDidChange() = 0; + + // Playlist + virtual bool PlaylistWillChange() = 0; + virtual bool ResetPlaylistEntries() = 0; + virtual bool SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText ) = 0; + virtual bool SetCurrentPlaylistEntry( int nID ) = 0; + virtual bool PlaylistDidChange() = 0; +}; + +#define STEAMMUSICREMOTE_INTERFACE_VERSION "STEAMMUSICREMOTE_INTERFACE_VERSION001" + +// Global interface accessor +inline ISteamMusicRemote *SteamMusicRemote(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusicRemote *, SteamMusicRemote, STEAMMUSICREMOTE_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillActivate_t, k_iSteamMusicRemoteCallbacks + 1) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillDeactivate_t, k_iSteamMusicRemoteCallbacks + 2 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerRemoteToFront_t, k_iSteamMusicRemoteCallbacks + 3 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWillQuit_t, k_iSteamMusicRemoteCallbacks + 4 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlay_t, k_iSteamMusicRemoteCallbacks + 5 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsPause_t, k_iSteamMusicRemoteCallbacks + 6 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayPrevious_t, k_iSteamMusicRemoteCallbacks + 7 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayNext_t, k_iSteamMusicRemoteCallbacks + 8 ) +STEAM_CALLBACK_END(0) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsShuffled_t, k_iSteamMusicRemoteCallbacks + 9 ) + STEAM_CALLBACK_MEMBER( 0, bool, m_bShuffled ) +STEAM_CALLBACK_END(1) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsLooped_t, k_iSteamMusicRemoteCallbacks + 10 ) + STEAM_CALLBACK_MEMBER(0, bool, m_bLooped ) +STEAM_CALLBACK_END(1) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsVolume_t, k_iSteamMusicCallbacks + 11 ) + STEAM_CALLBACK_MEMBER(0, float, m_flNewVolume) +STEAM_CALLBACK_END(1) + +STEAM_CALLBACK_BEGIN( MusicPlayerSelectsQueueEntry_t, k_iSteamMusicCallbacks + 12 ) + STEAM_CALLBACK_MEMBER(0, int, nID ) +STEAM_CALLBACK_END(1) + +STEAM_CALLBACK_BEGIN( MusicPlayerSelectsPlaylistEntry_t, k_iSteamMusicCallbacks + 13 ) + STEAM_CALLBACK_MEMBER(0, int, nID ) +STEAM_CALLBACK_END(1) + +STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayingRepeatStatus_t, k_iSteamMusicRemoteCallbacks + 14 ) + STEAM_CALLBACK_MEMBER(0, int, m_nPlayingRepeatStatus ) +STEAM_CALLBACK_END(1) + +#pragma pack( pop ) + + + +#endif // #define ISTEAMMUSICREMOTE_H diff --git a/lsteamclient/steamworks_sdk_160/isteamnetworking.h b/lsteamclient/steamworks_sdk_160/isteamnetworking.h new file mode 100644 index 0000000000..b7e077a3b8 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamnetworking.h @@ -0,0 +1,343 @@ +//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to steam managing network connections between game clients & servers +// +//============================================================================= + +#ifndef ISTEAMNETWORKING +#define ISTEAMNETWORKING +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +// list of possible errors returned by SendP2PPacket() API +// these will be posted in the P2PSessionConnectFail_t callback +enum EP2PSessionError +{ + k_EP2PSessionErrorNone = 0, + k_EP2PSessionErrorNoRightsToApp = 2, // local user doesn't own the app that is running + k_EP2PSessionErrorTimeout = 4, // target isn't responding, perhaps not calling AcceptP2PSessionWithUser() + // corporate firewalls can also block this (NAT traversal is not firewall traversal) + // make sure that UDP ports 3478, 4379, and 4380 are open in an outbound direction + + // The following error codes were removed and will never be sent. + // For privacy reasons, there is no reply if the user is offline or playing another game. + k_EP2PSessionErrorNotRunningApp_DELETED = 1, + k_EP2PSessionErrorDestinationNotLoggedIn_DELETED = 3, + + k_EP2PSessionErrorMax = 5 +}; + +// SendP2PPacket() send types +// Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets +enum EP2PSend +{ + // Basic UDP send. Packets can't be bigger than 1200 bytes (your typical MTU size). Can be lost, or arrive out of order (rare). + // The sending API does have some knowledge of the underlying connection, so if there is no NAT-traversal accomplished or + // there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again. + k_EP2PSendUnreliable = 0, + + // As above, but if the underlying p2p connection isn't yet established the packet will just be thrown away. Using this on the first + // packet sent to a remote host almost guarantees the packet will be dropped. + // This is only really useful for kinds of data that should never buffer up, i.e. voice payload packets + k_EP2PSendUnreliableNoDelay = 1, + + // Reliable message send. Can send up to 1MB of data in a single message. + // Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for efficient sends of large chunks of data. + k_EP2PSendReliable = 2, + + // As above, but applies the Nagle algorithm to the send - sends will accumulate + // until the current MTU size (typically ~1200 bytes, but can change) or ~200ms has passed (Nagle algorithm). + // Useful if you want to send a set of smaller messages but have the coalesced into a single packet + // Since the reliable stream is all ordered, you can do several small message sends with k_EP2PSendReliableWithBuffering and then + // do a normal k_EP2PSendReliable to force all the buffered data to be sent. + k_EP2PSendReliableWithBuffering = 3, + +}; + + +// connection state to a specified user, returned by GetP2PSessionState() +// this is under-the-hood info about what's going on with a SendP2PPacket(), shouldn't be needed except for debuggin +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif +struct P2PSessionState_t +{ + uint8 m_bConnectionActive; // true if we've got an active open connection + uint8 m_bConnecting; // true if we're currently trying to establish a connection + uint8 m_eP2PSessionError; // last error recorded (see enum above) + uint8 m_bUsingRelay; // true if it's going through a relay server (TURN) + int32 m_nBytesQueuedForSend; + int32 m_nPacketsQueuedForSend; + uint32 m_nRemoteIP; // potential IP:Port of remote host. Could be TURN server. + uint16 m_nRemotePort; // Only exists for compatibility with older authentication api's +}; +#pragma pack( pop ) + + +// handle to a socket +typedef uint32 SNetSocket_t; // CreateP2PConnectionSocket() +typedef uint32 SNetListenSocket_t; // CreateListenSocket() + +// connection progress indicators, used by CreateP2PConnectionSocket() +enum ESNetSocketState +{ + k_ESNetSocketStateInvalid = 0, + + // communication is valid + k_ESNetSocketStateConnected = 1, + + // states while establishing a connection + k_ESNetSocketStateInitiated = 10, // the connection state machine has started + + // p2p connections + k_ESNetSocketStateLocalCandidatesFound = 11, // we've found our local IP info + k_ESNetSocketStateReceivedRemoteCandidates = 12,// we've received information from the remote machine, via the Steam back-end, about their IP info + + // direct connections + k_ESNetSocketStateChallengeHandshake = 15, // we've received a challenge packet from the server + + // failure states + k_ESNetSocketStateDisconnecting = 21, // the API shut it down, and we're in the process of telling the other end + k_ESNetSocketStateLocalDisconnect = 22, // the API shut it down, and we've completed shutdown + k_ESNetSocketStateTimeoutDuringConnect = 23, // we timed out while trying to creating the connection + k_ESNetSocketStateRemoteEndDisconnected = 24, // the remote end has disconnected from us + k_ESNetSocketStateConnectionBroken = 25, // connection has been broken; either the other end has disappeared or our local network connection has broke + +}; + +// describes how the socket is currently connected +enum ESNetSocketConnectionType +{ + k_ESNetSocketConnectionTypeNotConnected = 0, + k_ESNetSocketConnectionTypeUDP = 1, + k_ESNetSocketConnectionTypeUDPRelay = 2, +}; + + +//----------------------------------------------------------------------------- +// Purpose: Functions for making connections and sending data between clients, +// traversing NAT's where possible +// +// NOTE: This interface is deprecated and may be removed in a future release of +/// the Steamworks SDK. Please see ISteamNetworkingSockets and +/// ISteamNetworkingMessages +//----------------------------------------------------------------------------- +class ISteamNetworking +{ +public: + //////////////////////////////////////////////////////////////////////////////////////////// + // + // UDP-style (connectionless) networking interface. These functions send messages using + // an API organized around the destination. Reliable and unreliable messages are supported. + // + // For a more TCP-style interface (meaning you have a connection handle), see the functions below. + // Both interface styles can send both reliable and unreliable messages. + // + // Automatically establishes NAT-traversing or Relay server connections + // + // These APIs are deprecated, and may be removed in a future version of the Steamworks + // SDK. See ISteamNetworkingMessages. + + // Sends a P2P packet to the specified user + // UDP-like, unreliable and a max packet size of 1200 bytes + // the first packet send may be delayed as the NAT-traversal code runs + // if we can't get through to the user, an error will be posted via the callback P2PSessionConnectFail_t + // see EP2PSend enum above for the descriptions of the different ways of sending packets + // + // nChannel is a routing number you can use to help route message to different systems - you'll have to call ReadP2PPacket() + // with the same channel number in order to retrieve the data on the other end + // using different channels to talk to the same user will still use the same underlying p2p connection, saving on resources + virtual bool SendP2PPacket( CSteamID steamIDRemote, const void *pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel = 0 ) = 0; + + // returns true if any data is available for read, and the amount of data that will need to be read + virtual bool IsP2PPacketAvailable( uint32 *pcubMsgSize, int nChannel = 0 ) = 0; + + // reads in a packet that has been sent from another user via SendP2PPacket() + // returns the size of the message and the steamID of the user who sent it in the last two parameters + // if the buffer passed in is too small, the message will be truncated + // this call is not blocking, and will return false if no data is available + virtual bool ReadP2PPacket( void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, CSteamID *psteamIDRemote, int nChannel = 0 ) = 0; + + // AcceptP2PSessionWithUser() should only be called in response to a P2PSessionRequest_t callback + // P2PSessionRequest_t will be posted if another user tries to send you a packet that you haven't talked to yet + // if you don't want to talk to the user, just ignore the request + // if the user continues to send you packets, another P2PSessionRequest_t will be posted periodically + // this may be called multiple times for a single user + // (if you've called SendP2PPacket() on the other user, this implicitly accepts the session request) + virtual bool AcceptP2PSessionWithUser( CSteamID steamIDRemote ) = 0; + + // call CloseP2PSessionWithUser() when you're done talking to a user, will free up resources under-the-hood + // if the remote user tries to send data to you again, another P2PSessionRequest_t callback will be posted + virtual bool CloseP2PSessionWithUser( CSteamID steamIDRemote ) = 0; + + // call CloseP2PChannelWithUser() when you're done talking to a user on a specific channel. Once all channels + // open channels to a user have been closed, the open session to the user will be closed and new data from this + // user will trigger a P2PSessionRequest_t callback + virtual bool CloseP2PChannelWithUser( CSteamID steamIDRemote, int nChannel ) = 0; + + // fills out P2PSessionState_t structure with details about the underlying connection to the user + // should only needed for debugging purposes + // returns false if no connection exists to the specified user + virtual bool GetP2PSessionState( CSteamID steamIDRemote, P2PSessionState_t *pConnectionState ) = 0; + + // Allow P2P connections to fall back to being relayed through the Steam servers if a direct connection + // or NAT-traversal cannot be established. Only applies to connections created after setting this value, + // or to existing connections that need to automatically reconnect after this value is set. + // + // P2P packet relay is allowed by default + // + // NOTE: This function is deprecated and may be removed in a future version of the SDK. For + // security purposes, we may decide to relay the traffic to certain peers, even if you pass false + // to this function, to prevent revealing the client's IP address top another peer. + virtual bool AllowP2PPacketRelay( bool bAllow ) = 0; + + + //////////////////////////////////////////////////////////////////////////////////////////// + // + // LISTEN / CONNECT connection-oriented interface functions + // + // These functions are more like a client-server TCP API. One side is the "server" + // and "listens" for incoming connections, which then must be "accepted." The "client" + // initiates a connection by "connecting." Sending and receiving is done through a + // connection handle. + // + // For a more UDP-style interface, where you do not track connection handles but + // simply send messages to a SteamID, use the UDP-style functions above. + // + // Both methods can send both reliable and unreliable methods. + // + // These APIs are deprecated, and may be removed in a future version of the Steamworks + // SDK. See ISteamNetworkingSockets. + // + //////////////////////////////////////////////////////////////////////////////////////////// + + + // creates a socket and listens others to connect + // will trigger a SocketStatusCallback_t callback on another client connecting + // nVirtualP2PPort is the unique ID that the client will connect to, in case you have multiple ports + // this can usually just be 0 unless you want multiple sets of connections + // unIP is the local IP address to bind to + // pass in 0 if you just want the default local IP + // unPort is the port to use + // pass in 0 if you don't want users to be able to connect via IP/Port, but expect to be always peer-to-peer connections only + virtual SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay ) = 0; + + // creates a socket and begin connection to a remote destination + // can connect via a known steamID (client or game server), or directly to an IP + // on success will trigger a SocketStatusCallback_t callback + // on failure or timeout will trigger a SocketStatusCallback_t callback with a failure code in m_eSNetSocketState + virtual SNetSocket_t CreateP2PConnectionSocket( CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay ) = 0; + virtual SNetSocket_t CreateConnectionSocket( SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec ) = 0; + + // disconnects the connection to the socket, if any, and invalidates the handle + // any unread data on the socket will be thrown away + // if bNotifyRemoteEnd is set, socket will not be completely destroyed until the remote end acknowledges the disconnect + virtual bool DestroySocket( SNetSocket_t hSocket, bool bNotifyRemoteEnd ) = 0; + // destroying a listen socket will automatically kill all the regular sockets generated from it + virtual bool DestroyListenSocket( SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ) = 0; + + // sending data + // must be a handle to a connected socket + // data is all sent via UDP, and thus send sizes are limited to 1200 bytes; after this, many routers will start dropping packets + // use the reliable flag with caution; although the resend rate is pretty aggressive, + // it can still cause stalls in receiving data (like TCP) + virtual bool SendDataOnSocket( SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable ) = 0; + + // receiving data + // returns false if there is no data remaining + // fills out *pcubMsgSize with the size of the next message, in bytes + virtual bool IsDataAvailableOnSocket( SNetSocket_t hSocket, uint32 *pcubMsgSize ) = 0; + + // fills in pubDest with the contents of the message + // messages are always complete, of the same size as was sent (i.e. packetized, not streaming) + // if *pcubMsgSize < cubDest, only partial data is written + // returns false if no data is available + virtual bool RetrieveDataFromSocket( SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0; + + // checks for data from any socket that has been connected off this listen socket + // returns false if there is no data remaining + // fills out *pcubMsgSize with the size of the next message, in bytes + // fills out *phSocket with the socket that data is available on + virtual bool IsDataAvailable( SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0; + + // retrieves data from any socket that has been connected off this listen socket + // fills in pubDest with the contents of the message + // messages are always complete, of the same size as was sent (i.e. packetized, not streaming) + // if *pcubMsgSize < cubDest, only partial data is written + // returns false if no data is available + // fills out *phSocket with the socket that data is available on + virtual bool RetrieveData( SNetListenSocket_t hListenSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0; + + // returns information about the specified socket, filling out the contents of the pointers + virtual bool GetSocketInfo( SNetSocket_t hSocket, CSteamID *pSteamIDRemote, int *peSocketStatus, SteamIPAddress_t *punIPRemote, uint16 *punPortRemote ) = 0; + + // returns which local port the listen socket is bound to + // *pnIP and *pnPort will be 0 if the socket is set to listen for P2P connections only + virtual bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, SteamIPAddress_t *pnIP, uint16 *pnPort ) = 0; + + // returns true to describe how the socket ended up connecting + virtual ESNetSocketConnectionType GetSocketConnectionType( SNetSocket_t hSocket ) = 0; + + // max packet size, in bytes + virtual int GetMaxPacketSize( SNetSocket_t hSocket ) = 0; +}; +#define STEAMNETWORKING_INTERFACE_VERSION "SteamNetworking006" + +// Global interface accessor +inline ISteamNetworking *SteamNetworking(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamNetworking, STEAMNETWORKING_INTERFACE_VERSION ); + +// Global accessor for the gameserver client +inline ISteamNetworking *SteamGameServerNetworking(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamGameServerNetworking, STEAMNETWORKING_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +// callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API +// in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them +struct P2PSessionRequest_t +{ + enum { k_iCallback = k_iSteamNetworkingCallbacks + 2 }; + CSteamID m_steamIDRemote; // user who wants to talk to us +}; + + +// callback notification - packets can't get through to the specified user via the SendP2PPacket() API +// all packets queued packets unsent at this point will be dropped +// further attempts to send will retry making the connection (but will be dropped if we fail again) +struct P2PSessionConnectFail_t +{ + enum { k_iCallback = k_iSteamNetworkingCallbacks + 3 }; + CSteamID m_steamIDRemote; // user we were sending packets to + uint8 m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble +}; + + +// callback notification - status of a socket has changed +// used as part of the CreateListenSocket() / CreateP2PConnectionSocket() +struct SocketStatusCallback_t +{ + enum { k_iCallback = k_iSteamNetworkingCallbacks + 1 }; + SNetSocket_t m_hSocket; // the socket used to send/receive data to the remote host + SNetListenSocket_t m_hListenSocket; // this is the server socket that we were listening on; NULL if this was an outgoing connection + CSteamID m_steamIDRemote; // remote steamID we have connected to, if it has one + int m_eSNetSocketState; // socket state, ESNetSocketState +}; + +#pragma pack( pop ) + +#endif // ISTEAMNETWORKING diff --git a/lsteamclient/steamworks_sdk_160/isteamnetworkingmessages.h b/lsteamclient/steamworks_sdk_160/isteamnetworkingmessages.h new file mode 100644 index 0000000000..2f3ead439e --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamnetworkingmessages.h @@ -0,0 +1,197 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== + +#ifndef ISTEAMNETWORKINGMESSAGES +#define ISTEAMNETWORKINGMESSAGES + +#include "steamnetworkingtypes.h" +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +/// The non-connection-oriented interface to send and receive messages +/// (whether they be "clients" or "servers"). +/// +/// ISteamNetworkingSockets is connection-oriented (like TCP), meaning you +/// need to listen and connect, and then you send messages using a connection +/// handle. ISteamNetworkingMessages is more like UDP, in that you can just send +/// messages to arbitrary peers at any time. The underlying connections are +/// established implicitly. +/// +/// Under the hood ISteamNetworkingMessages works on top of the ISteamNetworkingSockets +/// code, so you get the same routing and messaging efficiency. The difference is +/// mainly in your responsibility to explicitly establish a connection and +/// the type of feedback you get about the state of the connection. Both +/// interfaces can do "P2P" communications, and both support both unreliable +/// and reliable messages, fragmentation and reassembly. +/// +/// The primary purpose of this interface is to be "like UDP", so that UDP-based code +/// can be ported easily to take advantage of relayed connections. If you find +/// yourself needing more low level information or control, or to be able to better +/// handle failure, then you probably need to use ISteamNetworkingSockets directly. +/// Also, note that if your main goal is to obtain a connection between two peers +/// without concerning yourself with assigning roles of "client" and "server", +/// you may find the symmetric connection mode of ISteamNetworkingSockets useful. +/// (See k_ESteamNetworkingConfig_SymmetricConnect.) +/// +class ISteamNetworkingMessages +{ +public: + /// Sends a message to the specified host. If we don't already have a session with that user, + /// a session is implicitly created. There might be some handshaking that needs to happen + /// before we can actually begin sending message data. If this handshaking fails and we can't + /// get through, an error will be posted via the callback SteamNetworkingMessagesSessionFailed_t. + /// There is no notification when the operation succeeds. (You should have the peer send a reply + /// for this purpose.) + /// + /// Sending a message to a host will also implicitly accept any incoming connection from that host. + /// + /// nSendFlags is a bitmask of k_nSteamNetworkingSend_xxx options + /// + /// nRemoteChannel is a routing number you can use to help route message to different systems. + /// You'll have to call ReceiveMessagesOnChannel() with the same channel number in order to retrieve + /// the data on the other end. + /// + /// Using different channels to talk to the same user will still use the same underlying + /// connection, saving on resources. If you don't need this feature, use 0. + /// Otherwise, small integers are the most efficient. + /// + /// It is guaranteed that reliable messages to the same host on the same channel + /// will be be received by the remote host (if they are received at all) exactly once, + /// and in the same order that they were sent. + /// + /// NO other order guarantees exist! In particular, unreliable messages may be dropped, + /// received out of order with respect to each other and with respect to reliable data, + /// or may be received multiple times. Messages on different channels are *not* guaranteed + /// to be received in the order they were sent. + /// + /// A note for those familiar with TCP/IP ports, or converting an existing codebase that + /// opened multiple sockets: You might notice that there is only one channel, and with + /// TCP/IP each endpoint has a port number. You can think of the channel number as the + /// *destination* port. If you need each message to also include a "source port" (so the + /// recipient can route the reply), then just put that in your message. That is essentially + /// how UDP works! + /// + /// Returns: + /// - k_EREsultOK on success. + /// - k_EResultNoConnection, if the session has failed or was closed by the peer and + /// k_nSteamNetworkingSend_AutoRestartBrokenSession was not specified. (You can + /// use GetSessionConnectionInfo to get the details.) In order to acknowledge the + /// broken session and start a new one, you must call CloseSessionWithUser, or you may + /// repeat the call with k_nSteamNetworkingSend_AutoRestartBrokenSession. See + /// k_nSteamNetworkingSend_AutoRestartBrokenSession for more details. + /// - See ISteamNetworkingSockets::SendMessageToConnection for more possible return values + virtual EResult SendMessageToUser( const SteamNetworkingIdentity &identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0; + + /// Reads the next message that has been sent from another user via SendMessageToUser() on the given channel. + /// Returns number of messages returned into your list. (0 if no message are available on that channel.) + /// + /// When you're done with the message object(s), make sure and call SteamNetworkingMessage_t::Release()! + virtual int ReceiveMessagesOnChannel( int nLocalChannel, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0; + + /// Call this in response to a SteamNetworkingMessagesSessionRequest_t callback. + /// SteamNetworkingMessagesSessionRequest_t are posted when a user tries to send you a message, + /// and you haven't tried to talk to them first. If you don't want to talk to them, just ignore + /// the request. If the user continues to send you messages, SteamNetworkingMessagesSessionRequest_t + /// callbacks will continue to be posted periodically. + /// + /// Returns false if there is no session with the user pending or otherwise. If there is an + /// existing active session, this function will return true, even if it is not pending. + /// + /// Calling SendMessageToUser() will implicitly accepts any pending session request to that user. + virtual bool AcceptSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0; + + /// Call this when you're done talking to a user to immediately free up resources under-the-hood. + /// If the remote user tries to send data to you again, another SteamNetworkingMessagesSessionRequest_t + /// callback will be posted. + /// + /// Note that sessions that go unused for a few minutes are automatically timed out. + virtual bool CloseSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0; + + /// Call this when you're done talking to a user on a specific channel. Once all + /// open channels to a user have been closed, the open session to the user will be + /// closed, and any new data from this user will trigger a + /// SteamSteamNetworkingMessagesSessionRequest_t callback + virtual bool CloseChannelWithUser( const SteamNetworkingIdentity &identityRemote, int nLocalChannel ) = 0; + + /// Returns information about the latest state of a connection, if any, with the given peer. + /// Primarily intended for debugging purposes, but can also be used to get more detailed + /// failure information. (See SendMessageToUser and k_nSteamNetworkingSend_AutoRestartBrokenSession.) + /// + /// Returns the value of SteamNetConnectionInfo_t::m_eState, or k_ESteamNetworkingConnectionState_None + /// if no connection exists with specified peer. You may pass nullptr for either parameter if + /// you do not need the corresponding details. Note that sessions time out after a while, + /// so if a connection fails, or SendMessageToUser returns k_EResultNoConnection, you cannot wait + /// indefinitely to obtain the reason for failure. + virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetConnectionRealTimeStatus_t *pQuickStatus ) = 0; +}; +#define STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "SteamNetworkingMessages002" + +// +// Callbacks +// + +#pragma pack( push, 1 ) + +/// Posted when a remote host is sending us a message, and we do not already have a session with them +struct SteamNetworkingMessagesSessionRequest_t +{ + enum { k_iCallback = k_iSteamNetworkingMessagesCallbacks + 1 }; + SteamNetworkingIdentity m_identityRemote; // user who wants to talk to us +}; + +/// Posted when we fail to establish a connection, or we detect that communications +/// have been disrupted it an unusual way. There is no notification when a peer proactively +/// closes the session. ("Closed by peer" is not a concept of UDP-style communications, and +/// SteamNetworkingMessages is primarily intended to make porting UDP code easy.) +/// +/// Remember: callbacks are asynchronous. See notes on SendMessageToUser, +/// and k_nSteamNetworkingSend_AutoRestartBrokenSession in particular. +/// +/// Also, if a session times out due to inactivity, no callbacks will be posted. The only +/// way to detect that this is happening is that querying the session state may return +/// none, connecting, and findingroute again. +struct SteamNetworkingMessagesSessionFailed_t +{ + enum { k_iCallback = k_iSteamNetworkingMessagesCallbacks + 2 }; + + /// Detailed info about the session that failed. + /// SteamNetConnectionInfo_t::m_identityRemote indicates who this session + /// was with. + SteamNetConnectionInfo_t m_info; +}; + +#pragma pack(pop) + +// Global accessors + +// Using standalone lib +#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB + + static_assert( STEAMNETWORKINGMESSAGES_INTERFACE_VERSION[25] == '2', "Version mismatch" ); + + STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamNetworkingMessages_LibV2(); + inline ISteamNetworkingMessages *SteamNetworkingMessages_Lib() { return SteamNetworkingMessages_LibV2(); } + + // If running in context of steam, we also define a gameserver instance. + STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamGameServerNetworkingMessages_LibV2(); + inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages_Lib() { return SteamGameServerNetworkingMessages_LibV2(); } + + #ifndef STEAMNETWORKINGSOCKETS_STEAMAPI + inline ISteamNetworkingMessages *SteamNetworkingMessages() { return SteamNetworkingMessages_LibV2(); } + inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages() { return SteamGameServerNetworkingMessages_LibV2(); } + #endif +#endif + +// Using Steamworks SDK +#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI + + // Steamworks SDK + STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamNetworkingMessages_SteamAPI, STEAMNETWORKINGMESSAGES_INTERFACE_VERSION ); + STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamGameServerNetworkingMessages_SteamAPI, STEAMNETWORKINGMESSAGES_INTERFACE_VERSION ); + + #ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB + inline ISteamNetworkingMessages *SteamNetworkingMessages() { return SteamNetworkingMessages_SteamAPI(); } + inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages() { return SteamGameServerNetworkingMessages_SteamAPI(); } + #endif +#endif + +#endif // ISTEAMNETWORKINGMESSAGES diff --git a/lsteamclient/steamworks_sdk_160/isteamnetworkingsockets.h b/lsteamclient/steamworks_sdk_160/isteamnetworkingsockets.h new file mode 100644 index 0000000000..c631558b4e --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamnetworkingsockets.h @@ -0,0 +1,1029 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== + +#ifndef ISTEAMNETWORKINGSOCKETS +#define ISTEAMNETWORKINGSOCKETS + +#include "steamnetworkingtypes.h" +#include "steam_api_common.h" + +struct SteamNetAuthenticationStatus_t; +struct SteamNetworkingFakeIPResult_t; +class ISteamNetworkingConnectionSignaling; +class ISteamNetworkingSignalingRecvContext; +class ISteamNetworkingFakeUDPPort; + +//----------------------------------------------------------------------------- +/// Lower level networking API. +/// +/// - Connection-oriented API (like TCP, not UDP). When sending and receiving +/// messages, a connection handle is used. (For a UDP-style interface, where +/// the peer is identified by their address with each send/recv call, see +/// ISteamNetworkingMessages.) The typical pattern is for a "server" to "listen" +/// on a "listen socket." A "client" will "connect" to the server, and the +/// server will "accept" the connection. If you have a symmetric situation +/// where either peer may initiate the connection and server/client roles are +/// not clearly defined, check out k_ESteamNetworkingConfig_SymmetricConnect. +/// - But unlike TCP, it's message-oriented, not stream-oriented. +/// - Mix of reliable and unreliable messages +/// - Fragmentation and reassembly +/// - Supports connectivity over plain UDP +/// - Also supports SDR ("Steam Datagram Relay") connections, which are +/// addressed by the identity of the peer. There is a "P2P" use case and +/// a "hosted dedicated server" use case. +/// +/// Note that neither of the terms "connection" nor "socket" necessarily correspond +/// one-to-one with an underlying UDP socket. An attempt has been made to +/// keep the semantics as similar to the standard socket model when appropriate, +/// but some deviations do exist. +/// +/// See also: ISteamNetworkingMessages, the UDP-style interface. This API might be +/// easier to use, especially when porting existing UDP code. +class ISteamNetworkingSockets +{ +public: + + /// Creates a "server" socket that listens for clients to connect to by + /// calling ConnectByIPAddress, over ordinary UDP (IPv4 or IPv6) + /// + /// You must select a specific local port to listen on and set it + /// the port field of the local address. + /// + /// Usually you will set the IP portion of the address to zero (SteamNetworkingIPAddr::Clear()). + /// This means that you will not bind to any particular local interface (i.e. the same + /// as INADDR_ANY in plain socket code). Furthermore, if possible the socket will be bound + /// in "dual stack" mode, which means that it can accept both IPv4 and IPv6 client connections. + /// If you really do wish to bind a particular interface, then set the local address to the + /// appropriate IPv4 or IPv6 IP. + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + /// + /// When a client attempts to connect, a SteamNetConnectionStatusChangedCallback_t + /// will be posted. The connection will be in the connecting state. + virtual HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddress, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Creates a connection and begins talking to a "server" over UDP at the + /// given IPv4 or IPv6 address. The remote host must be listening with a + /// matching call to CreateListenSocketIP on the specified port. + /// + /// A SteamNetConnectionStatusChangedCallback_t callback will be triggered when we start + /// connecting, and then another one on either timeout or successful connection. + /// + /// If the server does not have any identity configured, then their network address + /// will be the only identity in use. Or, the network host may provide a platform-specific + /// identity with or without a valid certificate to authenticate that identity. (These + /// details will be contained in the SteamNetConnectionStatusChangedCallback_t.) It's + /// up to your application to decide whether to allow the connection. + /// + /// By default, all connections will get basic encryption sufficient to prevent + /// casual eavesdropping. But note that without certificates (or a shared secret + /// distributed through some other out-of-band mechanism), you don't have any + /// way of knowing who is actually on the other end, and thus are vulnerable to + /// man-in-the-middle attacks. + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + virtual HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Like CreateListenSocketIP, but clients will connect using ConnectP2P. + /// + /// nLocalVirtualPort specifies how clients can connect to this socket using + /// ConnectP2P. It's very common for applications to only have one listening socket; + /// in that case, use zero. If you need to open multiple listen sockets and have clients + /// be able to connect to one or the other, then nLocalVirtualPort should be a small + /// integer (<1000) unique to each listen socket you create. + /// + /// If you use this, you probably want to call ISteamNetworkingUtils::InitRelayNetworkAccess() + /// when your app initializes. + /// + /// If you are listening on a dedicated servers in known data center, + /// then you can listen using this function instead of CreateHostedDedicatedServerListenSocket, + /// to allow clients to connect without a ticket. Any user that owns + /// the app and is signed into Steam will be able to attempt to connect to + /// your server. Also, a connection attempt may require the client to + /// be connected to Steam, which is one more moving part that may fail. When + /// tickets are used, then once a ticket is obtained, a client can connect to + /// your server even if they got disconnected from Steam or Steam is offline. + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + virtual HSteamListenSocket CreateListenSocketP2P( int nLocalVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Begin connecting to a peer that is identified using a platform-specific identifier. + /// This uses the default rendezvous service, which depends on the platform and library + /// configuration. (E.g. on Steam, it goes through the steam backend.) + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + /// + /// To use your own signaling service, see: + /// - ConnectP2PCustomSignaling + /// - k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling + virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Accept an incoming connection that has been received on a listen socket. + /// + /// When a connection attempt is received (perhaps after a few basic handshake + /// packets have been exchanged to prevent trivial spoofing), a connection interface + /// object is created in the k_ESteamNetworkingConnectionState_Connecting state + /// and a SteamNetConnectionStatusChangedCallback_t is posted. At this point, your + /// application MUST either accept or close the connection. (It may not ignore it.) + /// Accepting the connection will transition it either into the connected state, + /// or the finding route state, depending on the connection type. + /// + /// You should take action within a second or two, because accepting the connection is + /// what actually sends the reply notifying the client that they are connected. If you + /// delay taking action, from the client's perspective it is the same as the network + /// being unresponsive, and the client may timeout the connection attempt. In other + /// words, the client cannot distinguish between a delay caused by network problems + /// and a delay caused by the application. + /// + /// This means that if your application goes for more than a few seconds without + /// processing callbacks (for example, while loading a map), then there is a chance + /// that a client may attempt to connect in that interval and fail due to timeout. + /// + /// If the application does not respond to the connection attempt in a timely manner, + /// and we stop receiving communication from the client, the connection attempt will + /// be timed out locally, transitioning the connection to the + /// k_ESteamNetworkingConnectionState_ProblemDetectedLocally state. The client may also + /// close the connection before it is accepted, and a transition to the + /// k_ESteamNetworkingConnectionState_ClosedByPeer is also possible depending the exact + /// sequence of events. + /// + /// Returns k_EResultInvalidParam if the handle is invalid. + /// Returns k_EResultInvalidState if the connection is not in the appropriate state. + /// (Remember that the connection state could change in between the time that the + /// notification being posted to the queue and when it is received by the application.) + /// + /// A note about connection configuration options. If you need to set any configuration + /// options that are common to all connections accepted through a particular listen + /// socket, consider setting the options on the listen socket, since such options are + /// inherited automatically. If you really do need to set options that are connection + /// specific, it is safe to set them on the connection before accepting the connection. + virtual EResult AcceptConnection( HSteamNetConnection hConn ) = 0; + + /// Disconnects from the remote host and invalidates the connection handle. + /// Any unread data on the connection is discarded. + /// + /// nReason is an application defined code that will be received on the other + /// end and recorded (when possible) in backend analytics. The value should + /// come from a restricted range. (See ESteamNetConnectionEnd.) If you don't need + /// to communicate any information to the remote host, and do not want analytics to + /// be able to distinguish "normal" connection terminations from "exceptional" ones, + /// You may pass zero, in which case the generic value of + /// k_ESteamNetConnectionEnd_App_Generic will be used. + /// + /// pszDebug is an optional human-readable diagnostic string that will be received + /// by the remote host and recorded (when possible) in backend analytics. + /// + /// If you wish to put the socket into a "linger" state, where an attempt is made to + /// flush any remaining sent data, use bEnableLinger=true. Otherwise reliable data + /// is not flushed. + /// + /// If the connection has already ended and you are just freeing up the + /// connection interface, the reason code, debug string, and linger flag are + /// ignored. + virtual bool CloseConnection( HSteamNetConnection hPeer, int nReason, const char *pszDebug, bool bEnableLinger ) = 0; + + /// Destroy a listen socket. All the connections that were accepting on the listen + /// socket are closed ungracefully. + virtual bool CloseListenSocket( HSteamListenSocket hSocket ) = 0; + + /// Set connection user data. the data is returned in the following places + /// - You can query it using GetConnectionUserData. + /// - The SteamNetworkingmessage_t structure. + /// - The SteamNetConnectionInfo_t structure. + /// (Which is a member of SteamNetConnectionStatusChangedCallback_t -- but see WARNINGS below!!!!) + /// + /// Do you need to set this atomically when the connection is created? + /// See k_ESteamNetworkingConfig_ConnectionUserData. + /// + /// WARNING: Be *very careful* when using the value provided in callbacks structs. + /// Callbacks are queued, and the value that you will receive in your + /// callback is the userdata that was effective at the time the callback + /// was queued. There are subtle race conditions that can happen if you + /// don't understand this! + /// + /// If any incoming messages for this connection are queued, the userdata + /// field is updated, so that when when you receive messages (e.g. with + /// ReceiveMessagesOnConnection), they will always have the very latest + /// userdata. So the tricky race conditions that can happen with callbacks + /// do not apply to retrieving messages. + /// + /// Returns false if the handle is invalid. + virtual bool SetConnectionUserData( HSteamNetConnection hPeer, int64 nUserData ) = 0; + + /// Fetch connection user data. Returns -1 if handle is invalid + /// or if you haven't set any userdata on the connection. + virtual int64 GetConnectionUserData( HSteamNetConnection hPeer ) = 0; + + /// Set a name for the connection, used mostly for debugging + virtual void SetConnectionName( HSteamNetConnection hPeer, const char *pszName ) = 0; + + /// Fetch connection name. Returns false if handle is invalid + virtual bool GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen ) = 0; + + /// Send a message to the remote host on the specified connection. + /// + /// nSendFlags determines the delivery guarantees that will be provided, + /// when data should be buffered, etc. E.g. k_nSteamNetworkingSend_Unreliable + /// + /// Note that the semantics we use for messages are not precisely + /// the same as the semantics of a standard "stream" socket. + /// (SOCK_STREAM) For an ordinary stream socket, the boundaries + /// between chunks are not considered relevant, and the sizes of + /// the chunks of data written will not necessarily match up to + /// the sizes of the chunks that are returned by the reads on + /// the other end. The remote host might read a partial chunk, + /// or chunks might be coalesced. For the message semantics + /// used here, however, the sizes WILL match. Each send call + /// will match a successful read call on the remote host + /// one-for-one. If you are porting existing stream-oriented + /// code to the semantics of reliable messages, your code should + /// work the same, since reliable message semantics are more + /// strict than stream semantics. The only caveat is related to + /// performance: there is per-message overhead to retain the + /// message sizes, and so if your code sends many small chunks + /// of data, performance will suffer. Any code based on stream + /// sockets that does not write excessively small chunks will + /// work without any changes. + /// + /// The pOutMessageNumber is an optional pointer to receive the + /// message number assigned to the message, if sending was successful. + /// + /// Returns: + /// - k_EResultInvalidParam: invalid connection handle, or the individual message is too big. + /// (See k_cbMaxSteamNetworkingSocketsMessageSizeSend) + /// - k_EResultInvalidState: connection is in an invalid state + /// - k_EResultNoConnection: connection has ended + /// - k_EResultIgnored: You used k_nSteamNetworkingSend_NoDelay, and the message was dropped because + /// we were not ready to send it. + /// - k_EResultLimitExceeded: there was already too much data queued to be sent. + /// (See k_ESteamNetworkingConfig_SendBufferSize) + virtual EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, int nSendFlags, int64 *pOutMessageNumber ) = 0; + + /// Send one or more messages without copying the message payload. + /// This is the most efficient way to send messages. To use this + /// function, you must first allocate a message object using + /// ISteamNetworkingUtils::AllocateMessage. (Do not declare one + /// on the stack or allocate your own.) + /// + /// You should fill in the message payload. You can either let + /// it allocate the buffer for you and then fill in the payload, + /// or if you already have a buffer allocated, you can just point + /// m_pData at your buffer and set the callback to the appropriate function + /// to free it. Note that if you use your own buffer, it MUST remain valid + /// until the callback is executed. And also note that your callback can be + /// invoked at any time from any thread (perhaps even before SendMessages + /// returns!), so it MUST be fast and threadsafe. + /// + /// You MUST also fill in: + /// - m_conn - the handle of the connection to send the message to + /// - m_nFlags - bitmask of k_nSteamNetworkingSend_xxx flags. + /// + /// All other fields are currently reserved and should not be modified. + /// + /// The library will take ownership of the message structures. They may + /// be modified or become invalid at any time, so you must not read them + /// after passing them to this function. + /// + /// pOutMessageNumberOrResult is an optional array that will receive, + /// for each message, the message number that was assigned to the message + /// if sending was successful. If sending failed, then a negative EResult + /// value is placed into the array. For example, the array will hold + /// -k_EResultInvalidState if the connection was in an invalid state. + /// See ISteamNetworkingSockets::SendMessageToConnection for possible + /// failure codes. + virtual void SendMessages( int nMessages, SteamNetworkingMessage_t *const *pMessages, int64 *pOutMessageNumberOrResult ) = 0; + + /// Flush any messages waiting on the Nagle timer and send them + /// at the next transmission opportunity (often that means right now). + /// + /// If Nagle is enabled (it's on by default) then when calling + /// SendMessageToConnection the message will be buffered, up to the Nagle time + /// before being sent, to merge small messages into the same packet. + /// (See k_ESteamNetworkingConfig_NagleTime) + /// + /// Returns: + /// k_EResultInvalidParam: invalid connection handle + /// k_EResultInvalidState: connection is in an invalid state + /// k_EResultNoConnection: connection has ended + /// k_EResultIgnored: We weren't (yet) connected, so this operation has no effect. + virtual EResult FlushMessagesOnConnection( HSteamNetConnection hConn ) = 0; + + /// Fetch the next available message(s) from the connection, if any. + /// Returns the number of messages returned into your array, up to nMaxMessages. + /// If the connection handle is invalid, -1 is returned. + /// + /// The order of the messages returned in the array is relevant. + /// Reliable messages will be received in the order they were sent (and with the + /// same sizes --- see SendMessageToConnection for on this subtle difference from a stream socket). + /// + /// Unreliable messages may be dropped, or delivered out of order with respect to + /// each other or with respect to reliable messages. The same unreliable message + /// may be received multiple times. + /// + /// If any messages are returned, you MUST call SteamNetworkingMessage_t::Release() on each + /// of them free up resources after you are done. It is safe to keep the object alive for + /// a little while (put it into some queue, etc), and you may call Release() from any thread. + virtual int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0; + + /// Returns basic information about the high-level state of the connection. + virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0; + + /// Returns a small set of information about the real-time state of the connection + /// and the queue status of each lane. + /// + /// - pStatus may be NULL if the information is not desired. (E.g. you are only interested + /// in the lane information.) + /// - On entry, nLanes specifies the length of the pLanes array. This may be 0 + /// if you do not wish to receive any lane data. It's OK for this to be smaller than + /// the total number of configured lanes. + /// - pLanes points to an array that will receive lane-specific info. It can be NULL + /// if this is not needed. + /// + /// Return value: + /// - k_EResultNoConnection - connection handle is invalid or connection has been closed. + /// - k_EResultInvalidParam - nLanes is bad + virtual EResult GetConnectionRealTimeStatus( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus, + int nLanes, SteamNetConnectionRealTimeLaneStatus_t *pLanes ) = 0; + + /// Returns detailed connection stats in text format. Useful + /// for dumping to a log, etc. + /// + /// Returns: + /// -1 failure (bad connection handle) + /// 0 OK, your buffer was filled in and '\0'-terminated + /// >0 Your buffer was either nullptr, or it was too small and the text got truncated. + /// Try again with a buffer of at least N bytes. + virtual int GetDetailedConnectionStatus( HSteamNetConnection hConn, char *pszBuf, int cbBuf ) = 0; + + /// Returns local IP and port that a listen socket created using CreateListenSocketIP is bound to. + /// + /// An IPv6 address of ::0 means "any IPv4 or IPv6" + /// An IPv6 address of ::ffff:0000:0000 means "any IPv4" + virtual bool GetListenSocketAddress( HSteamListenSocket hSocket, SteamNetworkingIPAddr *address ) = 0; + + /// Create a pair of connections that are talking to each other, e.g. a loopback connection. + /// This is very useful for testing, or so that your client/server code can work the same + /// even when you are running a local "server". + /// + /// The two connections will immediately be placed into the connected state, and no callbacks + /// will be posted immediately. After this, if you close either connection, the other connection + /// will receive a callback, exactly as if they were communicating over the network. You must + /// close *both* sides in order to fully clean up the resources! + /// + /// By default, internal buffers are used, completely bypassing the network, the chopping up of + /// messages into packets, encryption, copying the payload, etc. This means that loopback + /// packets, by default, will not simulate lag or loss. Passing true for bUseNetworkLoopback will + /// cause the socket pair to send packets through the local network loopback device (127.0.0.1) + /// on ephemeral ports. Fake lag and loss are supported in this case, and CPU time is expended + /// to encrypt and decrypt. + /// + /// If you wish to assign a specific identity to either connection, you may pass a particular + /// identity. Otherwise, if you pass nullptr, the respective connection will assume a generic + /// "localhost" identity. If you use real network loopback, this might be translated to the + /// actual bound loopback port. Otherwise, the port will be zero. + virtual bool CreateSocketPair( HSteamNetConnection *pOutConnection1, HSteamNetConnection *pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity *pIdentity1, const SteamNetworkingIdentity *pIdentity2 ) = 0; + + /// Configure multiple outbound messages streams ("lanes") on a connection, and + /// control head-of-line blocking between them. Messages within a given lane + /// are always sent in the order they are queued, but messages from different + /// lanes may be sent out of order. Each lane has its own message number + /// sequence. The first message sent on each lane will be assigned the number 1. + /// + /// Each lane has a "priority". Lanes with higher numeric values will only be processed + /// when all lanes with lower number values are empty. The magnitudes of the priority + /// values are not relevant, only their sort order. + /// + /// Each lane also is assigned a weight, which controls the approximate proportion + /// of the bandwidth that will be consumed by the lane, relative to other lanes + /// of the same priority. (This is assuming the lane stays busy. An idle lane + /// does not build up "credits" to be be spent once a message is queued.) + /// This value is only meaningful as a proportion, relative to other lanes with + /// the same priority. For lanes with different priorities, the strict priority + /// order will prevail, and their weights relative to each other are not relevant. + /// Thus, if a lane has a unique priority value, the weight value for that lane is + /// not relevant. + /// + /// Example: 3 lanes, with priorities [ 0, 10, 10 ] and weights [ (NA), 20, 5 ]. + /// Messages sent on the first will always be sent first, before messages in the + /// other two lanes. Its weight value is irrelevant, since there are no other + /// lanes with priority=0. The other two lanes will share bandwidth, with the second + /// and third lanes sharing bandwidth using a ratio of approximately 4:1. + /// (The weights [ NA, 4, 1 ] would be equivalent.) + /// + /// Notes: + /// - At the time of this writing, some code has performance cost that is linear + /// in the number of lanes, so keep the number of lanes to an absolute minimum. + /// 3 or so is fine; >8 is a lot. The max number of lanes on Steam is 255, + /// which is a very large number and not recommended! If you are compiling this + /// library from source, see STEAMNETWORKINGSOCKETS_MAX_LANES.) + /// - Lane priority values may be any int. Their absolute value is not relevant, + /// only the order matters. + /// - Weights must be positive, and due to implementation details, they are restricted + /// to 16-bit values. The absolute magnitudes don't matter, just the proportions. + /// - Messages sent on a lane index other than 0 have a small overhead on the wire, + /// so for maximum wire efficiency, lane 0 should be the "most common" lane, regardless + /// of priorities or weights. + /// - A connection has a single lane by default. Calling this function with + /// nNumLanes=1 is legal, but pointless, since the priority and weight values are + /// irrelevant in that case. + /// - You may reconfigure connection lanes at any time, however reducing the number of + /// lanes is not allowed. + /// - Reconfiguring lanes might restart any bandwidth sharing balancing. Usually you + /// will call this function once, near the start of the connection, perhaps after + /// exchanging a few messages. + /// - To assign all lanes the same priority, you may use pLanePriorities=NULL. + /// - If you wish all lanes with the same priority to share bandwidth equally (or + /// if no two lanes have the same priority value, and thus priority values are + /// irrelevant), you may use pLaneWeights=NULL + /// - Priorities and weights determine the order that messages are SENT on the wire. + /// There are NO GUARANTEES on the order that messages are RECEIVED! Due to packet + /// loss, out-of-order delivery, and subtle details of packet serialization, messages + /// might still be received slightly out-of-order! The *only* strong guarantee is that + /// *reliable* messages on the *same lane* will be delivered in the order they are sent. + /// - Each host configures the lanes for the packets they send; the lanes for the flow + /// in one direction are completely unrelated to the lanes in the opposite direction. + /// + /// Return value: + /// - k_EResultNoConnection - bad hConn + /// - k_EResultInvalidParam - Invalid number of lanes, bad weights, or you tried to reduce the number of lanes + /// - k_EResultInvalidState - Connection is already dead, etc + /// + /// See also: + /// SteamNetworkingMessage_t::m_idxLane + virtual EResult ConfigureConnectionLanes( HSteamNetConnection hConn, int nNumLanes, const int *pLanePriorities, const uint16 *pLaneWeights ) = 0; + + // + // Identity and authentication + // + + /// Get the identity assigned to this interface. + /// E.g. on Steam, this is the user's SteamID, or for the gameserver interface, the SteamID assigned + /// to the gameserver. Returns false and sets the result to an invalid identity if we don't know + /// our identity yet. (E.g. GameServer has not logged in. On Steam, the user will know their SteamID + /// even if they are not signed into Steam.) + virtual bool GetIdentity( SteamNetworkingIdentity *pIdentity ) = 0; + + /// Indicate our desire to be ready participate in authenticated communications. + /// If we are currently not ready, then steps will be taken to obtain the necessary + /// certificates. (This includes a certificate for us, as well as any CA certificates + /// needed to authenticate peers.) + /// + /// You can call this at program init time if you know that you are going to + /// be making authenticated connections, so that we will be ready immediately when + /// those connections are attempted. (Note that essentially all connections require + /// authentication, with the exception of ordinary UDP connections with authentication + /// disabled using k_ESteamNetworkingConfig_IP_AllowWithoutAuth.) If you don't call + /// this function, we will wait until a feature is utilized that that necessitates + /// these resources. + /// + /// You can also call this function to force a retry, if failure has occurred. + /// Once we make an attempt and fail, we will not automatically retry. + /// In this respect, the behavior of the system after trying and failing is the same + /// as before the first attempt: attempting authenticated communication or calling + /// this function will call the system to attempt to acquire the necessary resources. + /// + /// You can use GetAuthenticationStatus or listen for SteamNetAuthenticationStatus_t + /// to monitor the status. + /// + /// Returns the current value that would be returned from GetAuthenticationStatus. + virtual ESteamNetworkingAvailability InitAuthentication() = 0; + + /// Query our readiness to participate in authenticated communications. A + /// SteamNetAuthenticationStatus_t callback is posted any time this status changes, + /// but you can use this function to query it at any time. + /// + /// The value of SteamNetAuthenticationStatus_t::m_eAvail is returned. If you only + /// want this high level status, you can pass NULL for pDetails. If you want further + /// details, pass non-NULL to receive them. + virtual ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStatus_t *pDetails ) = 0; + + // + // Poll groups. A poll group is a set of connections that can be polled efficiently. + // (In our API, to "poll" a connection means to retrieve all pending messages. We + // actually don't have an API to "poll" the connection *state*, like BSD sockets.) + // + + /// Create a new poll group. + /// + /// You should destroy the poll group when you are done using DestroyPollGroup + virtual HSteamNetPollGroup CreatePollGroup() = 0; + + /// Destroy a poll group created with CreatePollGroup(). + /// + /// If there are any connections in the poll group, they are removed from the group, + /// and left in a state where they are not part of any poll group. + /// Returns false if passed an invalid poll group handle. + virtual bool DestroyPollGroup( HSteamNetPollGroup hPollGroup ) = 0; + + /// Assign a connection to a poll group. Note that a connection may only belong to a + /// single poll group. Adding a connection to a poll group implicitly removes it from + /// any other poll group it is in. + /// + /// You can pass k_HSteamNetPollGroup_Invalid to remove a connection from its current + /// poll group without adding it to a new poll group. + /// + /// If there are received messages currently pending on the connection, an attempt + /// is made to add them to the queue of messages for the poll group in approximately + /// the order that would have applied if the connection was already part of the poll + /// group at the time that the messages were received. + /// + /// Returns false if the connection handle is invalid, or if the poll group handle + /// is invalid (and not k_HSteamNetPollGroup_Invalid). + virtual bool SetConnectionPollGroup( HSteamNetConnection hConn, HSteamNetPollGroup hPollGroup ) = 0; + + /// Same as ReceiveMessagesOnConnection, but will return the next messages available + /// on any connection in the poll group. Examine SteamNetworkingMessage_t::m_conn + /// to know which connection. (SteamNetworkingMessage_t::m_nConnUserData might also + /// be useful.) + /// + /// Delivery order of messages among different connections will usually match the + /// order that the last packet was received which completed the message. But this + /// is not a strong guarantee, especially for packets received right as a connection + /// is being assigned to poll group. + /// + /// Delivery order of messages on the same connection is well defined and the + /// same guarantees are present as mentioned in ReceiveMessagesOnConnection. + /// (But the messages are not grouped by connection, so they will not necessarily + /// appear consecutively in the list; they may be interleaved with messages for + /// other connections.) + virtual int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0; + + // + // Clients connecting to dedicated servers hosted in a data center, + // using tickets issued by your game coordinator. If you are not + // issuing your own tickets to restrict who can attempt to connect + // to your server, then you won't use these functions. + // + + /// Call this when you receive a ticket from your backend / matchmaking system. Puts the + /// ticket into a persistent cache, and optionally returns the parsed ticket. + /// + /// See stamdatagram_ticketgen.h for more details. + virtual bool ReceivedRelayAuthTicket( const void *pvTicket, int cbTicket, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0; + + /// Search cache for a ticket to talk to the server on the specified virtual port. + /// If found, returns the number of seconds until the ticket expires, and optionally + /// the complete cracked ticket. Returns 0 if we don't have a ticket. + /// + /// Typically this is useful just to confirm that you have a ticket, before you + /// call ConnectToHostedDedicatedServer to connect to the server. + virtual int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameServer, int nRemoteVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0; + + /// Client call to connect to a server hosted in a Valve data center, on the specified virtual + /// port. You must have placed a ticket for this server into the cache, or else this connect + /// attempt will fail! If you are not issuing your own tickets, then to connect to a dedicated + /// server via SDR in auto-ticket mode, use ConnectP2P. (The server must be configured to allow + /// this type of connection by listening using CreateListenSocketP2P.) + /// + /// You may wonder why tickets are stored in a cache, instead of simply being passed as an argument + /// here. The reason is to make reconnection to a gameserver robust, even if the client computer loses + /// connection to Steam or the central backend, or the app is restarted or crashes, etc. + /// + /// If you use this, you probably want to call ISteamNetworkingUtils::InitRelayNetworkAccess() + /// when your app initializes + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + virtual HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity &identityTarget, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + // + // Servers hosted in data centers known to the Valve relay network + // + + /// Returns the value of the SDR_LISTEN_PORT environment variable. This + /// is the UDP server your server will be listening on. This will + /// configured automatically for you in production environments. + /// + /// In development, you'll need to set it yourself. See + /// https://partner.steamgames.com/doc/api/ISteamNetworkingSockets + /// for more information on how to configure dev environments. + virtual uint16 GetHostedDedicatedServerPort() = 0; + + /// Returns 0 if SDR_LISTEN_PORT is not set. Otherwise, returns the data center the server + /// is running in. This will be k_SteamDatagramPOPID_dev in non-production environment. + virtual SteamNetworkingPOPID GetHostedDedicatedServerPOPID() = 0; + + /// Return info about the hosted server. This contains the PoPID of the server, + /// and opaque routing information that can be used by the relays to send traffic + /// to your server. + /// + /// You will need to send this information to your backend, and put it in tickets, + /// so that the relays will know how to forward traffic from + /// clients to your server. See SteamDatagramRelayAuthTicket for more info. + /// + /// Also, note that the routing information is contained in SteamDatagramGameCoordinatorServerLogin, + /// so if possible, it's preferred to use GetGameCoordinatorServerLogin to send this info + /// to your game coordinator service, and also login securely at the same time. + /// + /// On a successful exit, k_EResultOK is returned + /// + /// Unsuccessful exit: + /// - Something other than k_EResultOK is returned. + /// - k_EResultInvalidState: We are not configured to listen for SDR (SDR_LISTEN_SOCKET + /// is not set.) + /// - k_EResultPending: we do not (yet) have the authentication information needed. + /// (See GetAuthenticationStatus.) If you use environment variables to pre-fetch + /// the network config, this data should always be available immediately. + /// - A non-localized diagnostic debug message will be placed in m_data that describes + /// the cause of the failure. + /// + /// NOTE: The returned blob is not encrypted. Send it to your backend, but don't + /// directly share it with clients. + virtual EResult GetHostedDedicatedServerAddress( SteamDatagramHostedAddress *pRouting ) = 0; + + /// Create a listen socket on the specified virtual port. The physical UDP port to use + /// will be determined by the SDR_LISTEN_PORT environment variable. If a UDP port is not + /// configured, this call will fail. + /// + /// This call MUST be made through the SteamGameServerNetworkingSockets() interface. + /// + /// This function should be used when you are using the ticket generator library + /// to issue your own tickets. Clients connecting to the server on this virtual + /// port will need a ticket, and they must connect using ConnectToHostedDedicatedServer. + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + virtual HSteamListenSocket CreateHostedDedicatedServerListenSocket( int nLocalVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Generate an authentication blob that can be used to securely login with + /// your backend, using SteamDatagram_ParseHostedServerLogin. (See + /// steamdatagram_gamecoordinator.h) + /// + /// Before calling the function: + /// - Populate the app data in pLoginInfo (m_cbAppData and m_appData). You can leave + /// all other fields uninitialized. + /// - *pcbSignedBlob contains the size of the buffer at pBlob. (It should be + /// at least k_cbMaxSteamDatagramGameCoordinatorServerLoginSerialized.) + /// + /// On a successful exit: + /// - k_EResultOK is returned + /// - All of the remaining fields of pLoginInfo will be filled out. + /// - *pcbSignedBlob contains the size of the serialized blob that has been + /// placed into pBlob. + /// + /// Unsuccessful exit: + /// - Something other than k_EResultOK is returned. + /// - k_EResultNotLoggedOn: you are not logged in (yet) + /// - See GetHostedDedicatedServerAddress for more potential failure return values. + /// - A non-localized diagnostic debug message will be placed in pBlob that describes + /// the cause of the failure. + /// + /// This works by signing the contents of the SteamDatagramGameCoordinatorServerLogin + /// with the cert that is issued to this server. In dev environments, it's OK if you do + /// not have a cert. (You will need to enable insecure dev login in SteamDatagram_ParseHostedServerLogin.) + /// Otherwise, you will need a signed cert. + /// + /// NOTE: The routing blob returned here is not encrypted. Send it to your backend + /// and don't share it directly with clients. + virtual EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *pLoginInfo, int *pcbSignedBlob, void *pBlob ) = 0; + + + // + // Relayed connections using custom signaling protocol + // + // This is used if you have your own method of sending out-of-band + // signaling / rendezvous messages through a mutually trusted channel. + // + + /// Create a P2P "client" connection that does signaling over a custom + /// rendezvous/signaling channel. + /// + /// pSignaling points to a new object that you create just for this connection. + /// It must stay valid until Release() is called. Once you pass the + /// object to this function, it assumes ownership. Release() will be called + /// from within the function call if the call fails. Furthermore, until Release() + /// is called, you should be prepared for methods to be invoked on your + /// object from any thread! You need to make sure your object is threadsafe! + /// Furthermore, you should make sure that dispatching the methods is done + /// as quickly as possible. + /// + /// This function will immediately construct a connection in the "connecting" + /// state. Soon after (perhaps before this function returns, perhaps in another thread), + /// the connection will begin sending signaling messages by calling + /// ISteamNetworkingConnectionSignaling::SendSignal. + /// + /// When the remote peer accepts the connection (See + /// ISteamNetworkingSignalingRecvContext::OnConnectRequest), + /// it will begin sending signaling messages. When these messages are received, + /// you can pass them to the connection using ReceivedP2PCustomSignal. + /// + /// If you know the identity of the peer that you expect to be on the other end, + /// you can pass their identity to improve debug output or just detect bugs. + /// If you don't know their identity yet, you can pass NULL, and their + /// identity will be established in the connection handshake. + /// + /// If you use this, you probably want to call ISteamNetworkingUtils::InitRelayNetworkAccess() + /// when your app initializes + /// + /// If you need to set any initial config options, pass them here. See + /// SteamNetworkingConfigValue_t for more about why this is preferable to + /// setting the options "immediately" after creation. + virtual HSteamNetConnection ConnectP2PCustomSignaling( ISteamNetworkingConnectionSignaling *pSignaling, const SteamNetworkingIdentity *pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// Called when custom signaling has received a message. When your + /// signaling channel receives a message, it should save off whatever + /// routing information was in the envelope into the context object, + /// and then pass the payload to this function. + /// + /// A few different things can happen next, depending on the message: + /// + /// - If the signal is associated with existing connection, it is dealt + /// with immediately. If any replies need to be sent, they will be + /// dispatched using the ISteamNetworkingConnectionSignaling + /// associated with the connection. + /// - If the message represents a connection request (and the request + /// is not redundant for an existing connection), a new connection + /// will be created, and ReceivedConnectRequest will be called on your + /// context object to determine how to proceed. + /// - Otherwise, the message is for a connection that does not + /// exist (anymore). In this case, we *may* call SendRejectionReply + /// on your context object. + /// + /// In any case, we will not save off pContext or access it after this + /// function returns. + /// + /// Returns true if the message was parsed and dispatched without anything + /// unusual or suspicious happening. Returns false if there was some problem + /// with the message that prevented ordinary handling. (Debug output will + /// usually have more information.) + /// + /// If you expect to be using relayed connections, then you probably want + /// to call ISteamNetworkingUtils::InitRelayNetworkAccess() when your app initializes + virtual bool ReceivedP2PCustomSignal( const void *pMsg, int cbMsg, ISteamNetworkingSignalingRecvContext *pContext ) = 0; + + // + // Certificate provision by the application. On Steam, we normally handle all this automatically + // and you will not need to use these advanced functions. + // + + /// Get blob that describes a certificate request. You can send this to your game coordinator. + /// Upon entry, *pcbBlob should contain the size of the buffer. On successful exit, it will + /// return the number of bytes that were populated. You can pass pBlob=NULL to query for the required + /// size. (512 bytes is a conservative estimate.) + /// + /// Pass this blob to your game coordinator and call SteamDatagram_CreateCert. + virtual bool GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg &errMsg ) = 0; + + /// Set the certificate. The certificate blob should be the output of + /// SteamDatagram_CreateCert. + virtual bool SetCertificate( const void *pCertificate, int cbCertificate, SteamNetworkingErrMsg &errMsg ) = 0; + + /// Reset the identity associated with this instance. + /// Any open connections are closed. Any previous certificates, etc are discarded. + /// You can pass a specific identity that you want to use, or you can pass NULL, + /// in which case the identity will be invalid until you set it using SetCertificate + /// + /// NOTE: This function is not actually supported on Steam! It is included + /// for use on other platforms where the active user can sign out and + /// a new user can sign in. + virtual void ResetIdentity( const SteamNetworkingIdentity *pIdentity ) = 0; + + // + // Misc + // + + /// Invoke all callback functions queued for this interface. + /// See k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, etc + /// + /// You don't need to call this if you are using Steam's callback dispatch + /// mechanism (SteamAPI_RunCallbacks and SteamGameserver_RunCallbacks). + virtual void RunCallbacks() = 0; + + // + // "FakeIP" system. + // + // A FakeIP is essentially a temporary, arbitrary identifier that + // happens to be a valid IPv4 address. The purpose of this system is to make it + // easy to integrate with existing code that identifies hosts using IPv4 addresses. + // The FakeIP address will never actually be used to send or receive any packets + // on the Internet, it is strictly an identifier. + // + // FakeIP addresses are designed to (hopefully) pass through existing code as + // transparently as possible, while conflicting with "real" addresses that might + // be in use on networks (both the Internet and LANs) in the same code as little + // as possible. At the time this comment is being written, they come from the + // 169.254.0.0/16 range, and the port number will always be >1024. HOWEVER, + // this is subject to change! Do not make assumptions about these addresses, + // or your code might break in the future. In particular, you should use + // functions such as ISteamNetworkingUtils::IsFakeIP to determine if an IP + // address is a "fake" one used by this system. + // + + /// Begin asynchronous process of allocating a fake IPv4 address that other + /// peers can use to contact us via P2P. IP addresses returned by this + /// function are globally unique for a given appid. + /// + /// nNumPorts is the numbers of ports you wish to reserve. This is useful + /// for the same reason that listening on multiple UDP ports is useful for + /// different types of traffic. Because these allocations come from a global + /// namespace, there is a relatively strict limit on the maximum number of + /// ports you may request. (At the time of this writing, the limit is 4.) + /// The port assignments are *not* guaranteed to have any particular order + /// or relationship! Do *not* assume they are contiguous, even though that + /// may often occur in practice. + /// + /// Returns false if a request was already in progress, true if a new request + /// was started. A SteamNetworkingFakeIPResult_t will be posted when the request + /// completes. + /// + /// For gameservers, you *must* call this after initializing the SDK but before + /// beginning login. Steam needs to know in advance that FakeIP will be used. + /// Everywhere your public IP would normally appear (such as the server browser) will be + /// replaced by the FakeIP, and the fake port at index 0. The request is actually queued + /// until the logon completes, so you must not wait until the allocation completes + /// before logging in. Except for trivial failures that can be detected locally + /// (e.g. invalid parameter), a SteamNetworkingFakeIPResult_t callback (whether success or + /// failure) will not be posted until after we have logged in. Furthermore, it is assumed + /// that FakeIP allocation is essential for your application to function, and so failure + /// will not be reported until *several* retries have been attempted. This process may + /// last several minutes. It is *highly* recommended to treat failure as fatal. + /// + /// To communicate using a connection-oriented (TCP-style) API: + /// - Server creates a listen socket using CreateListenSocketP2PFakeIP + /// - Client connects using ConnectByIPAddress, passing in the FakeIP address. + /// - The connection will behave mostly like a P2P connection. The identities + /// that appear in SteamNetConnectionInfo_t will be the FakeIP identity until + /// we know the real identity. Then it will be the real identity. If the + /// SteamNetConnectionInfo_t::m_addrRemote is valid, it will be a real IPv4 + /// address of a NAT-punched connection. Otherwise, it will not be valid. + /// + /// To communicate using an ad-hoc sendto/recv from (UDP-style) API, + /// use CreateFakeUDPPort. + virtual bool BeginAsyncRequestFakeIP( int nNumPorts ) = 0; + + /// Return info about the FakeIP and port(s) that we have been assigned, + /// if any. idxFirstPort is currently reserved and must be zero. + /// Make sure and check SteamNetworkingFakeIPResult_t::m_eResult + virtual void GetFakeIP( int idxFirstPort, SteamNetworkingFakeIPResult_t *pInfo ) = 0; + + /// Create a listen socket that will listen for P2P connections sent + /// to our FakeIP. A peer can initiate connections to this listen + /// socket by calling ConnectByIPAddress. + /// + /// idxFakePort refers to the *index* of the fake port requested, + /// not the actual port number. For example, pass 0 to refer to the + /// first port in the reservation. You must call this only after calling + /// BeginAsyncRequestFakeIP. However, you do not need to wait for the + /// request to complete before creating the listen socket. + virtual HSteamListenSocket CreateListenSocketP2PFakeIP( int idxFakePort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0; + + /// If the connection was initiated using the "FakeIP" system, then we + /// we can get an IP address for the remote host. If the remote host had + /// a global FakeIP at the time the connection was established, this + /// function will return that global IP. Otherwise, a FakeIP that is + /// unique locally will be allocated from the local FakeIP address space, + /// and that will be returned. + /// + /// The allocation of local FakeIPs attempts to assign addresses in + /// a consistent manner. If multiple connections are made to the + /// same remote host, they *probably* will return the same FakeIP. + /// However, since the namespace is limited, this cannot be guaranteed. + /// + /// On failure, returns: + /// - k_EResultInvalidParam: invalid connection handle + /// - k_EResultIPNotFound: This connection wasn't made using FakeIP system + virtual EResult GetRemoteFakeIPForConnection( HSteamNetConnection hConn, SteamNetworkingIPAddr *pOutAddr ) = 0; + + /// Get an interface that can be used like a UDP port to send/receive + /// datagrams to a FakeIP address. This is intended to make it easy + /// to port existing UDP-based code to take advantage of SDR. + /// + /// idxFakeServerPort refers to the *index* of the port allocated using + /// BeginAsyncRequestFakeIP and is used to create "server" ports. You may + /// call this before the allocation has completed. However, any attempts + /// to send packets will fail until the allocation has succeeded. When + /// the peer receives packets sent from this interface, the from address + /// of the packet will be the globally-unique FakeIP. If you call this + /// function multiple times and pass the same (nonnegative) fake port index, + /// the same object will be returned, and this object is not reference counted. + /// + /// To create a "client" port (e.g. the equivalent of an ephemeral UDP port) + /// pass -1. In this case, a distinct object will be returned for each call. + /// When the peer receives packets sent from this interface, the peer will + /// assign a FakeIP from its own locally-controlled namespace. + virtual ISteamNetworkingFakeUDPPort *CreateFakeUDPPort( int idxFakeServerPort ) = 0; + +protected: + ~ISteamNetworkingSockets(); // Silence some warnings +}; +#define STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "SteamNetworkingSockets012" + +// Global accessors + +// Using standalone lib +#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB + + static_assert( STEAMNETWORKINGSOCKETS_INTERFACE_VERSION[24] == '2', "Version mismatch" ); + STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets_LibV12(); + inline ISteamNetworkingSockets *SteamNetworkingSockets_Lib() { return SteamNetworkingSockets_LibV12(); } + + STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamGameServerNetworkingSockets_LibV12(); + inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets_Lib() { return SteamGameServerNetworkingSockets_LibV12(); } + + #ifndef STEAMNETWORKINGSOCKETS_STEAMAPI + inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_LibV12(); } + inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_LibV12(); } + #endif +#endif + +// Using Steamworks SDK +#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI + STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamNetworkingSockets_SteamAPI, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION ); + STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamGameServerNetworkingSockets_SteamAPI, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION ); + + #ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB + inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_SteamAPI(); } + inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_SteamAPI(); } + #endif +#endif + +/// Callback struct used to notify when a connection has changed state +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error "Must define VALVE_CALLBACK_PACK_SMALL or VALVE_CALLBACK_PACK_LARGE" +#endif + +/// This callback is posted whenever a connection is created, destroyed, or changes state. +/// The m_info field will contain a complete description of the connection at the time the +/// change occurred and the callback was posted. In particular, m_eState will have the +/// new connection state. +/// +/// You will usually need to listen for this callback to know when: +/// - A new connection arrives on a listen socket. +/// m_info.m_hListenSocket will be set, m_eOldState = k_ESteamNetworkingConnectionState_None, +/// and m_info.m_eState = k_ESteamNetworkingConnectionState_Connecting. +/// See ISteamNetworkigSockets::AcceptConnection. +/// - A connection you initiated has been accepted by the remote host. +/// m_eOldState = k_ESteamNetworkingConnectionState_Connecting, and +/// m_info.m_eState = k_ESteamNetworkingConnectionState_Connected. +/// Some connections might transition to k_ESteamNetworkingConnectionState_FindingRoute first. +/// - A connection has been actively rejected or closed by the remote host. +/// m_eOldState = k_ESteamNetworkingConnectionState_Connecting or k_ESteamNetworkingConnectionState_Connected, +/// and m_info.m_eState = k_ESteamNetworkingConnectionState_ClosedByPeer. m_info.m_eEndReason +/// and m_info.m_szEndDebug will have for more details. +/// NOTE: upon receiving this callback, you must still destroy the connection using +/// ISteamNetworkingSockets::CloseConnection to free up local resources. (The details +/// passed to the function are not used in this case, since the connection is already closed.) +/// - A problem was detected with the connection, and it has been closed by the local host. +/// The most common failure is timeout, but other configuration or authentication failures +/// can cause this. m_eOldState = k_ESteamNetworkingConnectionState_Connecting or +/// k_ESteamNetworkingConnectionState_Connected, and m_info.m_eState = k_ESteamNetworkingConnectionState_ProblemDetectedLocally. +/// m_info.m_eEndReason and m_info.m_szEndDebug will have for more details. +/// NOTE: upon receiving this callback, you must still destroy the connection using +/// ISteamNetworkingSockets::CloseConnection to free up local resources. (The details +/// passed to the function are not used in this case, since the connection is already closed.) +/// +/// Remember that callbacks are posted to a queue, and networking connections can +/// change at any time. It is possible that the connection has already changed +/// state by the time you process this callback. +/// +/// Also note that callbacks will be posted when connections are created and destroyed by your own API calls. +struct SteamNetConnectionStatusChangedCallback_t +{ + enum { k_iCallback = k_iSteamNetworkingSocketsCallbacks + 1 }; + + /// Connection handle + HSteamNetConnection m_hConn; + + /// Full connection info + SteamNetConnectionInfo_t m_info; + + /// Previous state. (Current state is in m_info.m_eState) + ESteamNetworkingConnectionState m_eOldState; +}; + +/// A struct used to describe our readiness to participate in authenticated, +/// encrypted communication. In order to do this we need: +/// +/// - The list of trusted CA certificates that might be relevant for this +/// app. +/// - A valid certificate issued by a CA. +/// +/// This callback is posted whenever the state of our readiness changes. +struct SteamNetAuthenticationStatus_t +{ + enum { k_iCallback = k_iSteamNetworkingSocketsCallbacks + 2 }; + + /// Status + ESteamNetworkingAvailability m_eAvail; + + /// Non-localized English language status. For diagnostic/debugging + /// purposes only. + char m_debugMsg[ 256 ]; +}; + +#pragma pack( pop ) + +#endif // ISTEAMNETWORKINGSOCKETS diff --git a/lsteamclient/steamworks_sdk_160/isteamnetworkingutils.h b/lsteamclient/steamworks_sdk_160/isteamnetworkingutils.h new file mode 100644 index 0000000000..ccd4311790 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamnetworkingutils.h @@ -0,0 +1,503 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Purpose: misc networking utilities +// +//============================================================================= + +#ifndef ISTEAMNETWORKINGUTILS +#define ISTEAMNETWORKINGUTILS + +#include "steamnetworkingtypes.h" +#include "steam_api_common.h" + +struct SteamDatagramRelayAuthTicket; +struct SteamRelayNetworkStatus_t; + +//----------------------------------------------------------------------------- +/// Misc networking utilities for checking the local networking environment +/// and estimating pings. +class ISteamNetworkingUtils +{ +public: + // + // Efficient message sending + // + + /// Allocate and initialize a message object. Usually the reason + /// you call this is to pass it to ISteamNetworkingSockets::SendMessages. + /// The returned object will have all of the relevant fields cleared to zero. + /// + /// Optionally you can also request that this system allocate space to + /// hold the payload itself. If cbAllocateBuffer is nonzero, the system + /// will allocate memory to hold a payload of at least cbAllocateBuffer bytes. + /// m_pData will point to the allocated buffer, m_cbSize will be set to the + /// size, and m_pfnFreeData will be set to the proper function to free up + /// the buffer. + /// + /// If cbAllocateBuffer=0, then no buffer is allocated. m_pData will be NULL, + /// m_cbSize will be zero, and m_pfnFreeData will be NULL. You will need to + /// set each of these. + virtual SteamNetworkingMessage_t *AllocateMessage( int cbAllocateBuffer ) = 0; + + // + // Access to Steam Datagram Relay (SDR) network + // + + // + // Initialization and status check + // + + /// If you know that you are going to be using the relay network (for example, + /// because you anticipate making P2P connections), call this to initialize the + /// relay network. If you do not call this, the initialization will + /// be delayed until the first time you use a feature that requires access + /// to the relay network, which will delay that first access. + /// + /// You can also call this to force a retry if the previous attempt has failed. + /// Performing any action that requires access to the relay network will also + /// trigger a retry, and so calling this function is never strictly necessary, + /// but it can be useful to call it a program launch time, if access to the + /// relay network is anticipated. + /// + /// Use GetRelayNetworkStatus or listen for SteamRelayNetworkStatus_t + /// callbacks to know when initialization has completed. + /// Typically initialization completes in a few seconds. + /// + /// Note: dedicated servers hosted in known data centers do *not* need + /// to call this, since they do not make routing decisions. However, if + /// the dedicated server will be using P2P functionality, it will act as + /// a "client" and this should be called. + inline void InitRelayNetworkAccess(); + + /// Fetch current status of the relay network. + /// + /// SteamRelayNetworkStatus_t is also a callback. It will be triggered on + /// both the user and gameserver interfaces any time the status changes, or + /// ping measurement starts or stops. + /// + /// SteamRelayNetworkStatus_t::m_eAvail is returned. If you want + /// more details, you can pass a non-NULL value. + virtual ESteamNetworkingAvailability GetRelayNetworkStatus( SteamRelayNetworkStatus_t *pDetails ) = 0; + + // + // "Ping location" functions + // + // We use the ping times to the valve relays deployed worldwide to + // generate a "marker" that describes the location of an Internet host. + // Given two such markers, we can estimate the network latency between + // two hosts, without sending any packets. The estimate is based on the + // optimal route that is found through the Valve network. If you are + // using the Valve network to carry the traffic, then this is precisely + // the ping you want. If you are not, then the ping time will probably + // still be a reasonable estimate. + // + // This is extremely useful to select peers for matchmaking! + // + // The markers can also be converted to a string, so they can be transmitted. + // We have a separate library you can use on your app's matchmaking/coordinating + // server to manipulate these objects. (See steamdatagram_gamecoordinator.h) + + /// Return location info for the current host. Returns the approximate + /// age of the data, in seconds, or -1 if no data is available. + /// + /// It takes a few seconds to initialize access to the relay network. If + /// you call this very soon after calling InitRelayNetworkAccess, + /// the data may not be available yet. + /// + /// This always return the most up-to-date information we have available + /// right now, even if we are in the middle of re-calculating ping times. + virtual float GetLocalPingLocation( SteamNetworkPingLocation_t &result ) = 0; + + /// Estimate the round-trip latency between two arbitrary locations, in + /// milliseconds. This is a conservative estimate, based on routing through + /// the relay network. For most basic relayed connections, this ping time + /// will be pretty accurate, since it will be based on the route likely to + /// be actually used. + /// + /// If a direct IP route is used (perhaps via NAT traversal), then the route + /// will be different, and the ping time might be better. Or it might actually + /// be a bit worse! Standard IP routing is frequently suboptimal! + /// + /// But even in this case, the estimate obtained using this method is a + /// reasonable upper bound on the ping time. (Also it has the advantage + /// of returning immediately and not sending any packets.) + /// + /// In a few cases we might not able to estimate the route. In this case + /// a negative value is returned. k_nSteamNetworkingPing_Failed means + /// the reason was because of some networking difficulty. (Failure to + /// ping, etc) k_nSteamNetworkingPing_Unknown is returned if we cannot + /// currently answer the question for some other reason. + /// + /// Do you need to be able to do this from a backend/matchmaking server? + /// You are looking for the "game coordinator" library. + virtual int EstimatePingTimeBetweenTwoLocations( const SteamNetworkPingLocation_t &location1, const SteamNetworkPingLocation_t &location2 ) = 0; + + /// Same as EstimatePingTime, but assumes that one location is the local host. + /// This is a bit faster, especially if you need to calculate a bunch of + /// these in a loop to find the fastest one. + /// + /// In rare cases this might return a slightly different estimate than combining + /// GetLocalPingLocation with EstimatePingTimeBetweenTwoLocations. That's because + /// this function uses a slightly more complete set of information about what + /// route would be taken. + virtual int EstimatePingTimeFromLocalHost( const SteamNetworkPingLocation_t &remoteLocation ) = 0; + + /// Convert a ping location into a text format suitable for sending over the wire. + /// The format is a compact and human readable. However, it is subject to change + /// so please do not parse it yourself. Your buffer must be at least + /// k_cchMaxSteamNetworkingPingLocationString bytes. + virtual void ConvertPingLocationToString( const SteamNetworkPingLocation_t &location, char *pszBuf, int cchBufSize ) = 0; + + /// Parse back SteamNetworkPingLocation_t string. Returns false if we couldn't understand + /// the string. + virtual bool ParsePingLocationString( const char *pszString, SteamNetworkPingLocation_t &result ) = 0; + + /// Check if the ping data of sufficient recency is available, and if + /// it's too old, start refreshing it. + /// + /// Please only call this function when you *really* do need to force an + /// immediate refresh of the data. (For example, in response to a specific + /// user input to refresh this information.) Don't call it "just in case", + /// before every connection, etc. That will cause extra traffic to be sent + /// for no benefit. The library will automatically refresh the information + /// as needed. + /// + /// Returns true if sufficiently recent data is already available. + /// + /// Returns false if sufficiently recent data is not available. In this + /// case, ping measurement is initiated, if it is not already active. + /// (You cannot restart a measurement already in progress.) + /// + /// You can use GetRelayNetworkStatus or listen for SteamRelayNetworkStatus_t + /// to know when ping measurement completes. + virtual bool CheckPingDataUpToDate( float flMaxAgeSeconds ) = 0; + + // + // List of Valve data centers, and ping times to them. This might + // be useful to you if you are use our hosting, or just need to measure + // latency to a cloud data center where we are running relays. + // + + /// Fetch ping time of best available relayed route from this host to + /// the specified data center. + virtual int GetPingToDataCenter( SteamNetworkingPOPID popID, SteamNetworkingPOPID *pViaRelayPoP ) = 0; + + /// Get *direct* ping time to the relays at the data center. + virtual int GetDirectPingToPOP( SteamNetworkingPOPID popID ) = 0; + + /// Get number of network points of presence in the config + virtual int GetPOPCount() = 0; + + /// Get list of all POP IDs. Returns the number of entries that were filled into + /// your list. + virtual int GetPOPList( SteamNetworkingPOPID *list, int nListSz ) = 0; + + // + // Misc + // + + /// Fetch current timestamp. This timer has the following properties: + /// + /// - Monotonicity is guaranteed. + /// - The initial value will be at least 24*3600*30*1e6, i.e. about + /// 30 days worth of microseconds. In this way, the timestamp value of + /// 0 will always be at least "30 days ago". Also, negative numbers + /// will never be returned. + /// - Wraparound / overflow is not a practical concern. + /// + /// If you are running under the debugger and stop the process, the clock + /// might not advance the full wall clock time that has elapsed between + /// calls. If the process is not blocked from normal operation, the + /// timestamp values will track wall clock time, even if you don't call + /// the function frequently. + /// + /// The value is only meaningful for this run of the process. Don't compare + /// it to values obtained on another computer, or other runs of the same process. + virtual SteamNetworkingMicroseconds GetLocalTimestamp() = 0; + + /// Set a function to receive network-related information that is useful for debugging. + /// This can be very useful during development, but it can also be useful for troubleshooting + /// problems with tech savvy end users. If you have a console or other log that customers + /// can examine, these log messages can often be helpful to troubleshoot network issues. + /// (Especially any warning/error messages.) + /// + /// The detail level indicates what message to invoke your callback on. Lower numeric + /// value means more important, and the value you pass is the lowest priority (highest + /// numeric value) you wish to receive callbacks for. + /// + /// The value here controls the detail level for most messages. You can control the + /// detail level for various subsystems (perhaps only for certain connections) by + /// adjusting the configuration values k_ESteamNetworkingConfig_LogLevel_Xxxxx. + /// + /// Except when debugging, you should only use k_ESteamNetworkingSocketsDebugOutputType_Msg + /// or k_ESteamNetworkingSocketsDebugOutputType_Warning. For best performance, do NOT + /// request a high detail level and then filter out messages in your callback. This incurs + /// all of the expense of formatting the messages, which are then discarded. Setting a high + /// priority value (low numeric value) here allows the library to avoid doing this work. + /// + /// IMPORTANT: This may be called from a service thread, while we own a mutex, etc. + /// Your output function must be threadsafe and fast! Do not make any other + /// Steamworks calls from within the handler. + virtual void SetDebugOutputFunction( ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ) = 0; + + // + // Fake IP + // + // Useful for interfacing with code that assumes peers are identified using an IPv4 address + // + + /// Return true if an IPv4 address is one that might be used as a "fake" one. + /// This function is fast; it just does some logical tests on the IP and does + /// not need to do any lookup operations. + inline bool IsFakeIPv4( uint32 nIPv4 ) { return GetIPv4FakeIPType( nIPv4 ) > k_ESteamNetworkingFakeIPType_NotFake; } + virtual ESteamNetworkingFakeIPType GetIPv4FakeIPType( uint32 nIPv4 ) = 0; + + /// Get the real identity associated with a given FakeIP. + /// + /// On failure, returns: + /// - k_EResultInvalidParam: the IP is not a FakeIP. + /// - k_EResultNoMatch: we don't recognize that FakeIP and don't know the corresponding identity. + /// + /// FakeIP's used by active connections, or the FakeIPs assigned to local identities, + /// will always work. FakeIPs for recently destroyed connections will continue to + /// return results for a little while, but not forever. At some point, we will forget + /// FakeIPs to save space. It's reasonably safe to assume that you can read back the + /// real identity of a connection very soon after it is destroyed. But do not wait + /// indefinitely. + virtual EResult GetRealIdentityForFakeIP( const SteamNetworkingIPAddr &fakeIP, SteamNetworkingIdentity *pOutRealIdentity ) = 0; + + // + // Set and get configuration values, see ESteamNetworkingConfigValue for individual descriptions. + // + + // Shortcuts for common cases. (Implemented as inline functions below) + bool SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val ); + bool SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val ); + bool SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val ); + bool SetGlobalConfigValuePtr( ESteamNetworkingConfigValue eValue, void *val ); + bool SetConnectionConfigValueInt32( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val ); + bool SetConnectionConfigValueFloat( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val ); + bool SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char *val ); + + // + // Set global callbacks. If you do not want to use Steam's callback dispatch mechanism and you + // want to use the same callback on all (or most) listen sockets and connections, then + // simply install these callbacks first thing, and you are good to go. + // See ISteamNetworkingSockets::RunCallbacks + // + bool SetGlobalCallback_SteamNetConnectionStatusChanged( FnSteamNetConnectionStatusChanged fnCallback ); + bool SetGlobalCallback_SteamNetAuthenticationStatusChanged( FnSteamNetAuthenticationStatusChanged fnCallback ); + bool SetGlobalCallback_SteamRelayNetworkStatusChanged( FnSteamRelayNetworkStatusChanged fnCallback ); + bool SetGlobalCallback_FakeIPResult( FnSteamNetworkingFakeIPResult fnCallback ); + bool SetGlobalCallback_MessagesSessionRequest( FnSteamNetworkingMessagesSessionRequest fnCallback ); + bool SetGlobalCallback_MessagesSessionFailed( FnSteamNetworkingMessagesSessionFailed fnCallback ); + + /// Set a configuration value. + /// - eValue: which value is being set + /// - eScope: Onto what type of object are you applying the setting? + /// - scopeArg: Which object you want to change? (Ignored for global scope). E.g. connection handle, listen socket handle, interface pointer, etc. + /// - eDataType: What type of data is in the buffer at pValue? This must match the type of the variable exactly! + /// - pArg: Value to set it to. You can pass NULL to remove a non-global setting at this scope, + /// causing the value for that object to use global defaults. Or at global scope, passing NULL + /// will reset any custom value and restore it to the system default. + /// NOTE: When setting pointers (e.g. callback functions), do not pass the function pointer directly. + /// Your argument should be a pointer to a function pointer. + virtual bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, + ESteamNetworkingConfigDataType eDataType, const void *pArg ) = 0; + + /// Set a configuration value, using a struct to pass the value. + /// (This is just a convenience shortcut; see below for the implementation and + /// a little insight into how SteamNetworkingConfigValue_t is used when + /// setting config options during listen socket and connection creation.) + bool SetConfigValueStruct( const SteamNetworkingConfigValue_t &opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj ); + + /// Get a configuration value. + /// - eValue: which value to fetch + /// - eScopeType: query setting on what type of object + /// - eScopeArg: the object to query the setting for + /// - pOutDataType: If non-NULL, the data type of the value is returned. + /// - pResult: Where to put the result. Pass NULL to query the required buffer size. (k_ESteamNetworkingGetConfigValue_BufferTooSmall will be returned.) + /// - cbResult: IN: the size of your buffer. OUT: the number of bytes filled in or required. + virtual ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, + ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult ) = 0; + + /// Get info about a configuration value. Returns the name of the value, + /// or NULL if the value doesn't exist. Other output parameters can be NULL + /// if you do not need them. + virtual const char *GetConfigValueInfo( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigDataType *pOutDataType, + ESteamNetworkingConfigScope *pOutScope ) = 0; + + /// Iterate the list of all configuration values in the current environment that it might + /// be possible to display or edit using a generic UI. To get the first iterable value, + /// pass k_ESteamNetworkingConfig_Invalid. Returns k_ESteamNetworkingConfig_Invalid + /// to signal end of list. + /// + /// The bEnumerateDevVars argument can be used to include "dev" vars. These are vars that + /// are recommended to only be editable in "debug" or "dev" mode and typically should not be + /// shown in a retail environment where a malicious local user might use this to cheat. + virtual ESteamNetworkingConfigValue IterateGenericEditableConfigValues( ESteamNetworkingConfigValue eCurrent, bool bEnumerateDevVars ) = 0; + + // + // String conversions. You'll usually access these using the respective + // inline methods. + // + virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort ) = 0; + virtual bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ) = 0; + virtual ESteamNetworkingFakeIPType SteamNetworkingIPAddr_GetFakeIPType( const SteamNetworkingIPAddr &addr ) = 0; + virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf ) = 0; + virtual bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr ) = 0; + +protected: + ~ISteamNetworkingUtils(); // Silence some warnings +}; +#define STEAMNETWORKINGUTILS_INTERFACE_VERSION "SteamNetworkingUtils004" + +// Global accessors +// Using standalone lib +#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB + + // Standalone lib + static_assert( STEAMNETWORKINGUTILS_INTERFACE_VERSION[22] == '4', "Version mismatch" ); + STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils_LibV4(); + inline ISteamNetworkingUtils *SteamNetworkingUtils_Lib() { return SteamNetworkingUtils_LibV4(); } + + #ifndef STEAMNETWORKINGSOCKETS_STEAMAPI + inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_LibV4(); } + #endif +#endif + +// Using Steamworks SDK +#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI + STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamNetworkingUtils *, SteamNetworkingUtils_SteamAPI, + /* Prefer user version of the interface. But if it isn't found, then use + gameserver one. Yes, this is a completely terrible hack */ + SteamInternal_FindOrCreateUserInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ) ? + SteamInternal_FindOrCreateUserInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ) : + SteamInternal_FindOrCreateGameServerInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ), + "global", + STEAMNETWORKINGUTILS_INTERFACE_VERSION + ) + + #ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB + inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_SteamAPI(); } + #endif +#endif + +/// A struct used to describe our readiness to use the relay network. +/// To do this we first need to fetch the network configuration, +/// which describes what POPs are available. +struct SteamRelayNetworkStatus_t +{ + enum { k_iCallback = k_iSteamNetworkingUtilsCallbacks + 1 }; + + /// Summary status. When this is "current", initialization has + /// completed. Anything else means you are not ready yet, or + /// there is a significant problem. + ESteamNetworkingAvailability m_eAvail; + + /// Nonzero if latency measurement is in progress (or pending, + /// awaiting a prerequisite). + int m_bPingMeasurementInProgress; + + /// Status obtaining the network config. This is a prerequisite + /// for relay network access. + /// + /// Failure to obtain the network config almost always indicates + /// a problem with the local internet connection. + ESteamNetworkingAvailability m_eAvailNetworkConfig; + + /// Current ability to communicate with ANY relay. Note that + /// the complete failure to communicate with any relays almost + /// always indicates a problem with the local Internet connection. + /// (However, just because you can reach a single relay doesn't + /// mean that the local connection is in perfect health.) + ESteamNetworkingAvailability m_eAvailAnyRelay; + + /// Non-localized English language status. For diagnostic/debugging + /// purposes only. + char m_debugMsg[ 256 ]; +}; + +#if 0 +#ifndef API_GEN + +/// Utility class for printing a SteamNetworkingIdentity. +/// E.g. printf( "Identity is '%s'\n", SteamNetworkingIdentityRender( identity ).c_str() ); +struct SteamNetworkingIdentityRender +{ + SteamNetworkingIdentityRender( const SteamNetworkingIdentity &x ) { x.ToString( buf, sizeof(buf) ); } + inline const char *c_str() const { return buf; } +private: + char buf[ SteamNetworkingIdentity::k_cchMaxString ]; +}; + +/// Utility class for printing a SteamNetworkingIPAddrRender. +struct SteamNetworkingIPAddrRender +{ + SteamNetworkingIPAddrRender( const SteamNetworkingIPAddr &x, bool bWithPort = true ) { x.ToString( buf, sizeof(buf), bWithPort ); } + inline const char *c_str() const { return buf; } +private: + char buf[ SteamNetworkingIPAddr::k_cchMaxString ]; +}; + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Internal stuff + +inline void ISteamNetworkingUtils::InitRelayNetworkAccess() { CheckPingDataUpToDate( 1e10f ); } +inline bool ISteamNetworkingUtils::SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Int32, &val ); } +inline bool ISteamNetworkingUtils::SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Float, &val ); } +inline bool ISteamNetworkingUtils::SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_String, val ); } +inline bool ISteamNetworkingUtils::SetGlobalConfigValuePtr( ESteamNetworkingConfigValue eValue, void *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Ptr, &val ); } // Note: passing pointer to pointer. +inline bool ISteamNetworkingUtils::SetConnectionConfigValueInt32( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_Int32, &val ); } +inline bool ISteamNetworkingUtils::SetConnectionConfigValueFloat( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_Float, &val ); } +inline bool ISteamNetworkingUtils::SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Connection, hConn, k_ESteamNetworkingConfig_String, val ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamNetConnectionStatusChanged( FnSteamNetConnectionStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, (void*)fnCallback ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamNetAuthenticationStatusChanged( FnSteamNetAuthenticationStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_AuthStatusChanged, (void*)fnCallback ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamRelayNetworkStatusChanged( FnSteamRelayNetworkStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged, (void*)fnCallback ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_FakeIPResult( FnSteamNetworkingFakeIPResult fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_FakeIPResult, (void*)fnCallback ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionRequest( FnSteamNetworkingMessagesSessionRequest fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_MessagesSessionRequest, (void*)fnCallback ); } +inline bool ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionFailed( FnSteamNetworkingMessagesSessionFailed fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_MessagesSessionFailed, (void*)fnCallback ); } + +inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingConfigValue_t &opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj ) +{ + // Locate the argument. Strings are a special case, since the + // "value" (the whole string buffer) doesn't fit in the struct + // NOTE: for pointer values, we pass a pointer to the pointer, + // we do not pass the pointer directly. + const void *pVal = ( opt.m_eDataType == k_ESteamNetworkingConfig_String ) ? (const void *)opt.m_val.m_string : (const void *)&opt.m_val; + return SetConfigValue( opt.m_eValue, eScopeType, scopeObj, opt.m_eDataType, pVal ); +} +#endif + +// How to get helper functions. +#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || defined(STEAMNETWORKINGSOCKETS_FOREXPORT) || defined( STEAMNETWORKINGSOCKETS_STANDALONELIB ) + + // Call direct to static functions + STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort ); + STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ); + STEAMNETWORKINGSOCKETS_INTERFACE ESteamNetworkingFakeIPType SteamNetworkingIPAddr_GetFakeIPType( const SteamNetworkingIPAddr *pAddr ); + STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity *pIdentity, char *buf, size_t cbBuf ); + STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr ); + inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); } + inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingIPAddr_ParseString( this, pszStr ); } + inline ESteamNetworkingFakeIPType SteamNetworkingIPAddr::GetFakeIPType() const { return SteamNetworkingIPAddr_GetFakeIPType( this ); } + inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingIdentity_ToString( this, buf, cbBuf ); } + inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingIdentity_ParseString( this, sizeof(*this), pszStr ); } + +#elif defined( STEAMNETWORKINGSOCKETS_STEAMAPI ) + // Using steamworks SDK - go through SteamNetworkingUtils() +#if 0 + inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); } + inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); } + inline ESteamNetworkingFakeIPType SteamNetworkingIPAddr::GetFakeIPType() const { return SteamNetworkingUtils()->SteamNetworkingIPAddr_GetFakeIPType( *this ); } + inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); } + inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); } +#endif +#else + #error "Invalid config" +#endif + +#endif // ISTEAMNETWORKINGUTILS diff --git a/lsteamclient/steamworks_sdk_160/isteamparentalsettings.h b/lsteamclient/steamworks_sdk_160/isteamparentalsettings.h new file mode 100644 index 0000000000..972e355c73 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamparentalsettings.h @@ -0,0 +1,65 @@ +//====== Copyright � 2013-, Valve Corporation, All rights reserved. ======= +// +// Purpose: Interface to Steam parental settings (Family View) +// +//============================================================================= + +#ifndef ISTEAMPARENTALSETTINGS_H +#define ISTEAMPARENTALSETTINGS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +// Feature types for parental settings +enum EParentalFeature +{ + k_EFeatureInvalid = 0, + k_EFeatureStore = 1, + k_EFeatureCommunity = 2, + k_EFeatureProfile = 3, + k_EFeatureFriends = 4, + k_EFeatureNews = 5, + k_EFeatureTrading = 6, + k_EFeatureSettings = 7, + k_EFeatureConsole = 8, + k_EFeatureBrowser = 9, + k_EFeatureParentalSetup = 10, + k_EFeatureLibrary = 11, + k_EFeatureTest = 12, + k_EFeatureSiteLicense = 13, + k_EFeatureKioskMode_Deprecated = 14, + k_EFeatureBlockAlways = 15, + k_EFeatureMax +}; + +class ISteamParentalSettings +{ +public: + virtual bool BIsParentalLockEnabled() = 0; + virtual bool BIsParentalLockLocked() = 0; + + virtual bool BIsAppBlocked( AppId_t nAppID ) = 0; + virtual bool BIsAppInBlockList( AppId_t nAppID ) = 0; + + virtual bool BIsFeatureBlocked( EParentalFeature eFeature ) = 0; + virtual bool BIsFeatureInBlockList( EParentalFeature eFeature ) = 0; +}; + +#define STEAMPARENTALSETTINGS_INTERFACE_VERSION "STEAMPARENTALSETTINGS_INTERFACE_VERSION001" + +// Global interface accessor +inline ISteamParentalSettings *SteamParentalSettings(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamParentalSettings *, SteamParentalSettings, STEAMPARENTALSETTINGS_INTERFACE_VERSION ); + +//----------------------------------------------------------------------------- +// Purpose: Callback for querying UGC +//----------------------------------------------------------------------------- +struct SteamParentalSettingsChanged_t +{ + enum { k_iCallback = k_ISteamParentalSettingsCallbacks + 1 }; +}; + + +#endif // ISTEAMPARENTALSETTINGS_H diff --git a/lsteamclient/steamworks_sdk_160/isteamps3overlayrenderer.h b/lsteamclient/steamworks_sdk_160/isteamps3overlayrenderer.h new file mode 100644 index 0000000000..4e07d4a194 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamps3overlayrenderer.h @@ -0,0 +1,91 @@ +//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface the game must provide Steam with on PS3 in order for the +// Steam overlay to render. +// +//============================================================================= + +#ifndef ISTEAMPS3OVERLAYRENDERER_H +#define ISTEAMPS3OVERLAYRENDERER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "cell/pad.h" + +//----------------------------------------------------------------------------- +// Purpose: Enum for supported gradient directions +//----------------------------------------------------------------------------- +enum EOverlayGradientDirection +{ + k_EOverlayGradientHorizontal = 1, + k_EOverlayGradientVertical = 2, + k_EOverlayGradientNone = 3, +}; + +// Helpers for fetching individual color components from ARGB packed DWORD colors Steam PS3 overlay renderer uses. +#define STEAM_COLOR_RED( color ) \ + (int)(((color)>>16)&0xff) + +#define STEAM_COLOR_GREEN( color ) \ + (int)(((color)>>8)&0xff) + +#define STEAM_COLOR_BLUE( color ) \ + (int)((color)&0xff) + +#define STEAM_COLOR_ALPHA( color ) \ + (int)(((color)>>24)&0xff) + + +//----------------------------------------------------------------------------- +// Purpose: Interface the game must expose to Steam for rendering +//----------------------------------------------------------------------------- +class ISteamPS3OverlayRenderHost +{ +public: + + // Interface for game engine to implement which Steam requires to render. + + // Draw a textured rect. This may use only part of the texture and will pass texture coords, it will also possibly request a gradient and will specify colors for vertexes. + virtual void DrawTexturedRect( int x0, int y0, int x1, int y1, float u0, float v0, float u1, float v1, int32 iTextureID, DWORD colorStart, DWORD colorEnd, EOverlayGradientDirection eDirection ) = 0; + + // Load a RGBA texture for Steam, or update a previously loaded one. Updates may be partial. You must not evict or remove this texture once Steam has uploaded it. + virtual void LoadOrUpdateTexture( int32 iTextureID, bool bIsFullTexture, int x0, int y0, uint32 uWidth, uint32 uHeight, int32 iBytes, char *pData ) = 0; + + // Delete a texture Steam previously uploaded + virtual void DeleteTexture( int32 iTextureID ) = 0; + + // Delete all previously uploaded textures + virtual void DeleteAllTextures() = 0; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Interface Steam exposes for the game to tell it when to render, etc. +//----------------------------------------------------------------------------- +class ISteamPS3OverlayRender +{ +public: + + // Call once at startup to initialize the Steam overlay and pass it your host interface ptr + virtual bool BHostInitialize( uint32 unScreenWidth, uint32 unScreenHeight, uint32 unRefreshRate, ISteamPS3OverlayRenderHost *pRenderHost, void *CellFontLib ) = 0; + + // Call this once a frame when you are ready for the Steam overlay to render (ie, right before flipping buffers, after all your rendering) + virtual void Render() = 0; + + // Call this everytime you read input on PS3. + // + // If this returns true, then the overlay is active and has consumed the input, your game + // should then ignore all the input until BHandleCellPadData once again returns false, which + // will mean the overlay is deactivated. + virtual bool BHandleCellPadData( const CellPadData &padData ) = 0; + + // Call this if you detect no controllers connected or that the XMB is intercepting input + // + // This is important to clear input state for the overlay, so keys left down during XMB activation + // are not continued to be processed. + virtual bool BResetInputState() = 0; +}; + + +#endif // ISTEAMPS3OVERLAYRENDERER_H \ No newline at end of file diff --git a/lsteamclient/steamworks_sdk_160/isteamremoteplay.h b/lsteamclient/steamworks_sdk_160/isteamremoteplay.h new file mode 100644 index 0000000000..df5ca3f48a --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamremoteplay.h @@ -0,0 +1,99 @@ +//============ Copyright (c) Valve Corporation, All rights reserved. ============ + +#ifndef ISTEAMREMOTEPLAY_H +#define ISTEAMREMOTEPLAY_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + + +//----------------------------------------------------------------------------- +// Purpose: The form factor of a device +//----------------------------------------------------------------------------- +enum ESteamDeviceFormFactor +{ + k_ESteamDeviceFormFactorUnknown = 0, + k_ESteamDeviceFormFactorPhone = 1, + k_ESteamDeviceFormFactorTablet = 2, + k_ESteamDeviceFormFactorComputer = 3, + k_ESteamDeviceFormFactorTV = 4, + k_ESteamDeviceFormFactorVRHeadset = 5, +}; + +// Steam Remote Play session ID +typedef uint32 RemotePlaySessionID_t; + + +//----------------------------------------------------------------------------- +// Purpose: Functions to provide information about Steam Remote Play sessions +//----------------------------------------------------------------------------- +class ISteamRemotePlay +{ +public: + // Get the number of currently connected Steam Remote Play sessions + virtual uint32 GetSessionCount() = 0; + + // Get the currently connected Steam Remote Play session ID at the specified index. Returns zero if index is out of bounds. + virtual RemotePlaySessionID_t GetSessionID( int iSessionIndex ) = 0; + + // Get the SteamID of the connected user + virtual CSteamID GetSessionSteamID( RemotePlaySessionID_t unSessionID ) = 0; + + // Get the name of the session client device + // This returns NULL if the sessionID is not valid + virtual const char *GetSessionClientName( RemotePlaySessionID_t unSessionID ) = 0; + + // Get the form factor of the session client device + virtual ESteamDeviceFormFactor GetSessionClientFormFactor( RemotePlaySessionID_t unSessionID ) = 0; + + // Get the resolution, in pixels, of the session client device + // This is set to 0x0 if the resolution is not available + virtual bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, int *pnResolutionX, int *pnResolutionY ) = 0; + + // Start Remote Play Together and optionally show the UI in the overlay + // This returns false if Remote Play Together can't be started or your game is not configured for Remote Play Together + virtual bool BStartRemotePlayTogether( bool bShowOverlay = true ) = 0; + + // Invite a friend to Remote Play Together, or create a guest invite if steamIDFriend is empty + // This will automatically start Remote Play Together if it hasn't already been started + // This returns false if the invite can't be sent or your game is not configured for Remote Play Together + virtual bool BSendRemotePlayTogetherInvite( CSteamID steamIDFriend ) = 0; +}; + +#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION002" + +// Global interface accessor +inline ISteamRemotePlay *SteamRemotePlay(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamRemotePlay *, SteamRemotePlay, STEAMREMOTEPLAY_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionConnected_t, k_iSteamRemotePlayCallbacks + 1 ) + STEAM_CALLBACK_MEMBER( 0, RemotePlaySessionID_t, m_unSessionID ) +STEAM_CALLBACK_END( 0 ) + + +STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionDisconnected_t, k_iSteamRemotePlayCallbacks + 2 ) + STEAM_CALLBACK_MEMBER( 0, RemotePlaySessionID_t, m_unSessionID ) +STEAM_CALLBACK_END( 0 ) + + +STEAM_CALLBACK_BEGIN( SteamRemotePlayTogetherGuestInvite_t, k_iSteamRemotePlayCallbacks + 3 ) + STEAM_CALLBACK_MEMBER_ARRAY( 0, char, m_szConnectURL, 1024 ) +STEAM_CALLBACK_END( 0 ) + + +#pragma pack( pop ) + + +#endif // #define ISTEAMREMOTEPLAY_H diff --git a/lsteamclient/steamworks_sdk_160/isteamremotestorage.h b/lsteamclient/steamworks_sdk_160/isteamremotestorage.h new file mode 100644 index 0000000000..c0da367e04 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamremotestorage.h @@ -0,0 +1,661 @@ +//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: public interface to user remote file storage in Steam +// +//============================================================================= + +#ifndef ISTEAMREMOTESTORAGE_H +#define ISTEAMREMOTESTORAGE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + + +//----------------------------------------------------------------------------- +// Purpose: Defines the largest allowed file size. Cloud files cannot be written +// in a single chunk over 100MB (and cannot be over 200MB total.) +//----------------------------------------------------------------------------- +const uint32 k_unMaxCloudFileChunkSize = 100 * 1024 * 1024; + + +//----------------------------------------------------------------------------- +// Purpose: Structure that contains an array of const char * strings and the number of those strings +//----------------------------------------------------------------------------- +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif +struct SteamParamStringArray_t +{ + const char ** m_ppStrings; + int32 m_nNumStrings; +}; +#pragma pack( pop ) + +// A handle to a piece of user generated content +typedef uint64 UGCHandle_t; +typedef uint64 PublishedFileUpdateHandle_t; +typedef uint64 PublishedFileId_t; +const PublishedFileId_t k_PublishedFileIdInvalid = 0; +const UGCHandle_t k_UGCHandleInvalid = 0xffffffffffffffffull; +const PublishedFileUpdateHandle_t k_PublishedFileUpdateHandleInvalid = 0xffffffffffffffffull; + +// Handle for writing to Steam Cloud +typedef uint64 UGCFileWriteStreamHandle_t; +const UGCFileWriteStreamHandle_t k_UGCFileStreamHandleInvalid = 0xffffffffffffffffull; + +const uint32 k_cchPublishedDocumentTitleMax = 128 + 1; +const uint32 k_cchPublishedDocumentDescriptionMax = 8000; +const uint32 k_cchPublishedDocumentChangeDescriptionMax = 8000; +const uint32 k_unEnumeratePublishedFilesMaxResults = 50; +const uint32 k_cchTagListMax = 1024 + 1; +const uint32 k_cchFilenameMax = 260; +const uint32 k_cchPublishedFileURLMax = 256; + + +enum ERemoteStoragePlatform +{ + k_ERemoteStoragePlatformNone = 0, + k_ERemoteStoragePlatformWindows = (1 << 0), + k_ERemoteStoragePlatformOSX = (1 << 1), + k_ERemoteStoragePlatformPS3 = (1 << 2), + k_ERemoteStoragePlatformLinux = (1 << 3), + k_ERemoteStoragePlatformSwitch = (1 << 4), + k_ERemoteStoragePlatformAndroid = (1 << 5), + k_ERemoteStoragePlatformIOS = (1 << 6), + // NB we get one more before we need to widen some things + + k_ERemoteStoragePlatformAll = 0xffffffff +}; + +enum ERemoteStoragePublishedFileVisibility +{ + k_ERemoteStoragePublishedFileVisibilityPublic = 0, + k_ERemoteStoragePublishedFileVisibilityFriendsOnly = 1, + k_ERemoteStoragePublishedFileVisibilityPrivate = 2, + k_ERemoteStoragePublishedFileVisibilityUnlisted = 3, +}; + + +enum EWorkshopFileType +{ + k_EWorkshopFileTypeFirst = 0, + + k_EWorkshopFileTypeCommunity = 0, // normal Workshop item that can be subscribed to + k_EWorkshopFileTypeMicrotransaction = 1, // Workshop item that is meant to be voted on for the purpose of selling in-game + k_EWorkshopFileTypeCollection = 2, // a collection of Workshop or Greenlight items + k_EWorkshopFileTypeArt = 3, // artwork + k_EWorkshopFileTypeVideo = 4, // external video + k_EWorkshopFileTypeScreenshot = 5, // screenshot + k_EWorkshopFileTypeGame = 6, // Greenlight game entry + k_EWorkshopFileTypeSoftware = 7, // Greenlight software entry + k_EWorkshopFileTypeConcept = 8, // Greenlight concept + k_EWorkshopFileTypeWebGuide = 9, // Steam web guide + k_EWorkshopFileTypeIntegratedGuide = 10, // application integrated guide + k_EWorkshopFileTypeMerch = 11, // Workshop merchandise meant to be voted on for the purpose of being sold + k_EWorkshopFileTypeControllerBinding = 12, // Steam Controller bindings + k_EWorkshopFileTypeSteamworksAccessInvite = 13, // internal + k_EWorkshopFileTypeSteamVideo = 14, // Steam video + k_EWorkshopFileTypeGameManagedItem = 15, // managed completely by the game, not the user, and not shown on the web + k_EWorkshopFileTypeClip = 16, // internal + + // Update k_EWorkshopFileTypeMax if you add values. + k_EWorkshopFileTypeMax = 17 + +}; + +enum EWorkshopVote +{ + k_EWorkshopVoteUnvoted = 0, + k_EWorkshopVoteFor = 1, + k_EWorkshopVoteAgainst = 2, + k_EWorkshopVoteLater = 3, +}; + +enum EWorkshopFileAction +{ + k_EWorkshopFileActionPlayed = 0, + k_EWorkshopFileActionCompleted = 1, +}; + +enum EWorkshopEnumerationType +{ + k_EWorkshopEnumerationTypeRankedByVote = 0, + k_EWorkshopEnumerationTypeRecent = 1, + k_EWorkshopEnumerationTypeTrending = 2, + k_EWorkshopEnumerationTypeFavoritesOfFriends = 3, + k_EWorkshopEnumerationTypeVotedByFriends = 4, + k_EWorkshopEnumerationTypeContentByFriends = 5, + k_EWorkshopEnumerationTypeRecentFromFollowedUsers = 6, +}; + +enum EWorkshopVideoProvider +{ + k_EWorkshopVideoProviderNone = 0, + k_EWorkshopVideoProviderYoutube = 1 +}; + + +enum EUGCReadAction +{ + // Keeps the file handle open unless the last byte is read. You can use this when reading large files (over 100MB) in sequential chunks. + // If the last byte is read, this will behave the same as k_EUGCRead_Close. Otherwise, it behaves the same as k_EUGCRead_ContinueReading. + // This value maintains the same behavior as before the EUGCReadAction parameter was introduced. + k_EUGCRead_ContinueReadingUntilFinished = 0, + + // Keeps the file handle open. Use this when using UGCRead to seek to different parts of the file. + // When you are done seeking around the file, make a final call with k_EUGCRead_Close to close it. + k_EUGCRead_ContinueReading = 1, + + // Frees the file handle. Use this when you're done reading the content. + // To read the file from Steam again you will need to call UGCDownload again. + k_EUGCRead_Close = 2, +}; + +enum ERemoteStorageLocalFileChange +{ + k_ERemoteStorageLocalFileChange_Invalid = 0, + + // The file was updated from another device + k_ERemoteStorageLocalFileChange_FileUpdated = 1, + + // The file was deleted by another device + k_ERemoteStorageLocalFileChange_FileDeleted = 2, +}; + +enum ERemoteStorageFilePathType +{ + k_ERemoteStorageFilePathType_Invalid = 0, + + // The file is directly accessed by the game and this is the full path + k_ERemoteStorageFilePathType_Absolute = 1, + + // The file is accessed via the ISteamRemoteStorage API and this is the filename + k_ERemoteStorageFilePathType_APIFilename = 2, +}; + + +//----------------------------------------------------------------------------- +// Purpose: Functions for accessing, reading and writing files stored remotely +// and cached locally +//----------------------------------------------------------------------------- +class ISteamRemoteStorage +{ + public: + // NOTE + // + // Filenames are case-insensitive, and will be converted to lowercase automatically. + // So "foo.bar" and "Foo.bar" are the same file, and if you write "Foo.bar" then + // iterate the files, the filename returned will be "foo.bar". + // + + // file operations + virtual bool FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0; + virtual int32 FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0; + + STEAM_CALL_RESULT( RemoteStorageFileWriteAsyncComplete_t ) + virtual SteamAPICall_t FileWriteAsync( const char *pchFile, const void *pvData, uint32 cubData ) = 0; + + STEAM_CALL_RESULT( RemoteStorageFileReadAsyncComplete_t ) + virtual SteamAPICall_t FileReadAsync( const char *pchFile, uint32 nOffset, uint32 cubToRead ) = 0; + virtual bool FileReadAsyncComplete( SteamAPICall_t hReadCall, void *pvBuffer, uint32 cubToRead ) = 0; + + virtual bool FileForget( const char *pchFile ) = 0; + virtual bool FileDelete( const char *pchFile ) = 0; + STEAM_CALL_RESULT( RemoteStorageFileShareResult_t ) + virtual SteamAPICall_t FileShare( const char *pchFile ) = 0; + virtual bool SetSyncPlatforms( const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0; + + // file operations that cause network IO + virtual UGCFileWriteStreamHandle_t FileWriteStreamOpen( const char *pchFile ) = 0; + virtual bool FileWriteStreamWriteChunk( UGCFileWriteStreamHandle_t writeHandle, const void *pvData, int32 cubData ) = 0; + virtual bool FileWriteStreamClose( UGCFileWriteStreamHandle_t writeHandle ) = 0; + virtual bool FileWriteStreamCancel( UGCFileWriteStreamHandle_t writeHandle ) = 0; + + // file information + virtual bool FileExists( const char *pchFile ) = 0; + virtual bool FilePersisted( const char *pchFile ) = 0; + virtual int32 GetFileSize( const char *pchFile ) = 0; + virtual int64 GetFileTimestamp( const char *pchFile ) = 0; + virtual ERemoteStoragePlatform GetSyncPlatforms( const char *pchFile ) = 0; + + // iteration + virtual int32 GetFileCount() = 0; + virtual const char *GetFileNameAndSize( int iFile, int32 *pnFileSizeInBytes ) = 0; + + // configuration management + virtual bool GetQuota( uint64 *pnTotalBytes, uint64 *puAvailableBytes ) = 0; + virtual bool IsCloudEnabledForAccount() = 0; + virtual bool IsCloudEnabledForApp() = 0; + virtual void SetCloudEnabledForApp( bool bEnabled ) = 0; + + // user generated content + + // Downloads a UGC file. A priority value of 0 will download the file immediately, + // otherwise it will wait to download the file until all downloads with a lower priority + // value are completed. Downloads with equal priority will occur simultaneously. + STEAM_CALL_RESULT( RemoteStorageDownloadUGCResult_t ) + virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent, uint32 unPriority ) = 0; + + // Gets the amount of data downloaded so far for a piece of content. pnBytesExpected can be 0 if function returns false + // or if the transfer hasn't started yet, so be careful to check for that before dividing to get a percentage + virtual bool GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected ) = 0; + + // Gets metadata for a file after it has been downloaded. This is the same metadata given in the RemoteStorageDownloadUGCResult_t call result + virtual bool GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, STEAM_OUT_STRING() char **ppchName, int32 *pnFileSizeInBytes, STEAM_OUT_STRUCT() CSteamID *pSteamIDOwner ) = 0; + + // After download, gets the content of the file. + // Small files can be read all at once by calling this function with an offset of 0 and cubDataToRead equal to the size of the file. + // Larger files can be read in chunks to reduce memory usage (since both sides of the IPC client and the game itself must allocate + // enough memory for each chunk). Once the last byte is read, the file is implicitly closed and further calls to UGCRead will fail + // unless UGCDownload is called again. + // For especially large files (anything over 100MB) it is a requirement that the file is read in chunks. + virtual int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction ) = 0; + + // Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead() + virtual int32 GetCachedUGCCount() = 0; + virtual UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0; + + // publishing UGC + STEAM_CALL_RESULT( RemoteStoragePublishFileProgress_t ) + virtual SteamAPICall_t PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags, EWorkshopFileType eWorkshopFileType ) = 0; + virtual PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId ) = 0; + virtual bool UpdatePublishedFileFile( PublishedFileUpdateHandle_t updateHandle, const char *pchFile ) = 0; + virtual bool UpdatePublishedFilePreviewFile( PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile ) = 0; + virtual bool UpdatePublishedFileTitle( PublishedFileUpdateHandle_t updateHandle, const char *pchTitle ) = 0; + virtual bool UpdatePublishedFileDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchDescription ) = 0; + virtual bool UpdatePublishedFileVisibility( PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; + virtual bool UpdatePublishedFileTags( PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags ) = 0; + STEAM_CALL_RESULT( RemoteStorageUpdatePublishedFileResult_t ) + virtual SteamAPICall_t CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHandle ) = 0; + // Gets published file details for the given publishedfileid. If unMaxSecondsOld is greater than 0, + // cached data may be returned, depending on how long ago it was cached. A value of 0 will force a refresh. + // A value of k_WorkshopForceLoadPublishedFileDetailsFromCache will use cached data if it exists, no matter how old it is. + STEAM_CALL_RESULT( RemoteStorageGetPublishedFileDetailsResult_t ) + virtual SteamAPICall_t GetPublishedFileDetails( PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld ) = 0; + STEAM_CALL_RESULT( RemoteStorageDeletePublishedFileResult_t ) + virtual SteamAPICall_t DeletePublishedFile( PublishedFileId_t unPublishedFileId ) = 0; + // enumerate the files that the current user published with this app + STEAM_CALL_RESULT( RemoteStorageEnumerateUserPublishedFilesResult_t ) + virtual SteamAPICall_t EnumerateUserPublishedFiles( uint32 unStartIndex ) = 0; + STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t ) + virtual SteamAPICall_t SubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0; + STEAM_CALL_RESULT( RemoteStorageEnumerateUserSubscribedFilesResult_t ) + virtual SteamAPICall_t EnumerateUserSubscribedFiles( uint32 unStartIndex ) = 0; + STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t ) + virtual SteamAPICall_t UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0; + virtual bool UpdatePublishedFileSetChangeDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription ) = 0; + STEAM_CALL_RESULT( RemoteStorageGetPublishedItemVoteDetailsResult_t ) + virtual SteamAPICall_t GetPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0; + STEAM_CALL_RESULT( RemoteStorageUpdateUserPublishedItemVoteResult_t ) + virtual SteamAPICall_t UpdateUserPublishedItemVote( PublishedFileId_t unPublishedFileId, bool bVoteUp ) = 0; + STEAM_CALL_RESULT( RemoteStorageGetPublishedItemVoteDetailsResult_t ) + virtual SteamAPICall_t GetUserPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0; + STEAM_CALL_RESULT( RemoteStorageEnumerateUserPublishedFilesResult_t ) + virtual SteamAPICall_t EnumerateUserSharedWorkshopFiles( CSteamID steamId, uint32 unStartIndex, SteamParamStringArray_t *pRequiredTags, SteamParamStringArray_t *pExcludedTags ) = 0; + STEAM_CALL_RESULT( RemoteStoragePublishFileProgress_t ) + virtual SteamAPICall_t PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *pchVideoAccount, const char *pchVideoIdentifier, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags ) = 0; + STEAM_CALL_RESULT( RemoteStorageSetUserPublishedFileActionResult_t ) + virtual SteamAPICall_t SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ) = 0; + STEAM_CALL_RESULT( RemoteStorageEnumeratePublishedFilesByUserActionResult_t ) + virtual SteamAPICall_t EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 unStartIndex ) = 0; + // this method enumerates the public view of workshop files + STEAM_CALL_RESULT( RemoteStorageEnumerateWorkshopFilesResult_t ) + virtual SteamAPICall_t EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags ) = 0; + + STEAM_CALL_RESULT( RemoteStorageDownloadUGCResult_t ) + virtual SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority ) = 0; + + // Cloud dynamic state change notification + virtual int32 GetLocalFileChangeCount() = 0; + virtual const char *GetLocalFileChange( int iFile, ERemoteStorageLocalFileChange *pEChangeType, ERemoteStorageFilePathType *pEFilePathType ) = 0; + + // Indicate to Steam the beginning / end of a set of local file + // operations - for example, writing a game save that requires updating two files. + virtual bool BeginFileWriteBatch() = 0; + virtual bool EndFileWriteBatch() = 0; +}; + +#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION016" + +// Global interface accessor +inline ISteamRemoteStorage *SteamRemoteStorage(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamRemoteStorage *, SteamRemoteStorage, STEAMREMOTESTORAGE_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to FileShare() +//----------------------------------------------------------------------------- +struct RemoteStorageFileShareResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 7 }; + EResult m_eResult; // The result of the operation + UGCHandle_t m_hFile; // The handle that can be shared with users and features + char m_rgchFilename[k_cchFilenameMax]; // The name of the file that was shared +}; + + +// k_iSteamRemoteStorageCallbacks + 8 is deprecated! Do not reuse + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to PublishFile() +//----------------------------------------------------------------------------- +struct RemoteStoragePublishFileResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 9 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; +}; + +// k_iSteamRemoteStorageCallbacks + 10 is deprecated! Do not reuse + + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to DeletePublishedFile() +//----------------------------------------------------------------------------- +struct RemoteStorageDeletePublishedFileResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 11 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to EnumerateUserPublishedFiles() +//----------------------------------------------------------------------------- +struct RemoteStorageEnumerateUserPublishedFilesResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 12 }; + EResult m_eResult; // The result of the operation. + int32 m_nResultsReturned; + int32 m_nTotalResultCount; + PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ]; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to SubscribePublishedFile() +//----------------------------------------------------------------------------- +struct RemoteStorageSubscribePublishedFileResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 13 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to EnumerateSubscribePublishedFiles() +//----------------------------------------------------------------------------- +struct RemoteStorageEnumerateUserSubscribedFilesResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 14 }; + EResult m_eResult; // The result of the operation. + int32 m_nResultsReturned; + int32 m_nTotalResultCount; + PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ]; + uint32 m_rgRTimeSubscribed[ k_unEnumeratePublishedFilesMaxResults ]; +}; + +#if defined(VALVE_CALLBACK_PACK_SMALL) + VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 ); +#elif defined(VALVE_CALLBACK_PACK_LARGE) + VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 + 4 ); +#else +#warning You must first include steam_api_common.h +#endif + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to UnsubscribePublishedFile() +//----------------------------------------------------------------------------- +struct RemoteStorageUnsubscribePublishedFileResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 15 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to CommitPublishedFileUpdate() +//----------------------------------------------------------------------------- +struct RemoteStorageUpdatePublishedFileResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 16 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to UGCDownload() +//----------------------------------------------------------------------------- +struct RemoteStorageDownloadUGCResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 17 }; + EResult m_eResult; // The result of the operation. + UGCHandle_t m_hFile; // The handle to the file that was attempted to be downloaded. + AppId_t m_nAppID; // ID of the app that created this file. + int32 m_nSizeInBytes; // The size of the file that was downloaded, in bytes. + char m_pchFileName[k_cchFilenameMax]; // The name of the file that was downloaded. + uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content. +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to GetPublishedFileDetails() +//----------------------------------------------------------------------------- +struct RemoteStorageGetPublishedFileDetailsResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 18 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; + AppId_t m_nCreatorAppID; // ID of the app that created this file. + AppId_t m_nConsumerAppID; // ID of the app that will consume this file. + char m_rgchTitle[k_cchPublishedDocumentTitleMax]; // title of document + char m_rgchDescription[k_cchPublishedDocumentDescriptionMax]; // description of document + UGCHandle_t m_hFile; // The handle of the primary file + UGCHandle_t m_hPreviewFile; // The handle of the preview file + uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content. + uint32 m_rtimeCreated; // time when the published file was created + uint32 m_rtimeUpdated; // time when the published file was last updated + ERemoteStoragePublishedFileVisibility m_eVisibility; + bool m_bBanned; + char m_rgchTags[k_cchTagListMax]; // comma separated list of all tags associated with this file + bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer + char m_pchFileName[k_cchFilenameMax]; // The name of the primary file + int32 m_nFileSize; // Size of the primary file + int32 m_nPreviewFileSize; // Size of the preview file + char m_rgchURL[k_cchPublishedFileURLMax]; // URL (for a video or a website) + EWorkshopFileType m_eFileType; // Type of the file + bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop +}; + + +struct RemoteStorageEnumerateWorkshopFilesResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 19 }; + EResult m_eResult; + int32 m_nResultsReturned; + int32 m_nTotalResultCount; + PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ]; + float m_rgScore[ k_unEnumeratePublishedFilesMaxResults ]; + AppId_t m_nAppId; + uint32 m_unStartIndex; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of GetPublishedItemVoteDetails +//----------------------------------------------------------------------------- +struct RemoteStorageGetPublishedItemVoteDetailsResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 20 }; + EResult m_eResult; + PublishedFileId_t m_unPublishedFileId; + int32 m_nVotesFor; + int32 m_nVotesAgainst; + int32 m_nReports; + float m_fScore; +}; + + +//----------------------------------------------------------------------------- +// Purpose: User subscribed to a file for the app (from within the app or on the web) +//----------------------------------------------------------------------------- +struct RemoteStoragePublishedFileSubscribed_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 21 }; + PublishedFileId_t m_nPublishedFileId; // The published file id + AppId_t m_nAppID; // ID of the app that will consume this file. +}; + +//----------------------------------------------------------------------------- +// Purpose: User unsubscribed from a file for the app (from within the app or on the web) +//----------------------------------------------------------------------------- +struct RemoteStoragePublishedFileUnsubscribed_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 22 }; + PublishedFileId_t m_nPublishedFileId; // The published file id + AppId_t m_nAppID; // ID of the app that will consume this file. +}; + + +//----------------------------------------------------------------------------- +// Purpose: Published file that a user owns was deleted (from within the app or the web) +//----------------------------------------------------------------------------- +struct RemoteStoragePublishedFileDeleted_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 23 }; + PublishedFileId_t m_nPublishedFileId; // The published file id + AppId_t m_nAppID; // ID of the app that will consume this file. +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to UpdateUserPublishedItemVote() +//----------------------------------------------------------------------------- +struct RemoteStorageUpdateUserPublishedItemVoteResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 24 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; // The published file id +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to GetUserPublishedItemVoteDetails() +//----------------------------------------------------------------------------- +struct RemoteStorageUserVoteDetails_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 25 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; // The published file id + EWorkshopVote m_eVote; // what the user voted +}; + +struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 26 }; + EResult m_eResult; // The result of the operation. + int32 m_nResultsReturned; + int32 m_nTotalResultCount; + PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ]; +}; + +struct RemoteStorageSetUserPublishedFileActionResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 27 }; + EResult m_eResult; // The result of the operation. + PublishedFileId_t m_nPublishedFileId; // The published file id + EWorkshopFileAction m_eAction; // the action that was attempted +}; + +struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 28 }; + EResult m_eResult; // The result of the operation. + EWorkshopFileAction m_eAction; // the action that was filtered on + int32 m_nResultsReturned; + int32 m_nTotalResultCount; + PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ]; + uint32 m_rgRTimeUpdated[ k_unEnumeratePublishedFilesMaxResults ]; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Called periodically while a PublishWorkshopFile is in progress +//----------------------------------------------------------------------------- +struct RemoteStoragePublishFileProgress_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 29 }; + double m_dPercentFile; + bool m_bPreview; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Called when the content for a published file is updated +//----------------------------------------------------------------------------- +struct RemoteStoragePublishedFileUpdated_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 30 }; + PublishedFileId_t m_nPublishedFileId; // The published file id + AppId_t m_nAppID; // ID of the app that will consume this file. + uint64 m_ulUnused; // not used anymore +}; + +//----------------------------------------------------------------------------- +// Purpose: Called when a FileWriteAsync completes +//----------------------------------------------------------------------------- +struct RemoteStorageFileWriteAsyncComplete_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 31 }; + EResult m_eResult; // result +}; + +//----------------------------------------------------------------------------- +// Purpose: Called when a FileReadAsync completes +//----------------------------------------------------------------------------- +struct RemoteStorageFileReadAsyncComplete_t +{ + enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 32 }; + SteamAPICall_t m_hFileReadAsync; // call handle of the async read which was made + EResult m_eResult; // result + uint32 m_nOffset; // offset in the file this read was at + uint32 m_cubRead; // amount read - will the <= the amount requested +}; + +//----------------------------------------------------------------------------- +// Purpose: one or more files for this app have changed locally after syncing +// to remote session changes +// Note: only posted if this happens DURING the local app session +//----------------------------------------------------------------------------- +STEAM_CALLBACK_BEGIN( RemoteStorageLocalFileChange_t, k_iSteamRemoteStorageCallbacks + 33 ) +STEAM_CALLBACK_END( 0 ) + +#pragma pack( pop ) + + +#endif // ISTEAMREMOTESTORAGE_H diff --git a/lsteamclient/steamworks_sdk_160/isteamscreenshots.h b/lsteamclient/steamworks_sdk_160/isteamscreenshots.h new file mode 100644 index 0000000000..18242682c3 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamscreenshots.h @@ -0,0 +1,120 @@ +//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: public interface to user remote file storage in Steam +// +//============================================================================= + +#ifndef ISTEAMSCREENSHOTS_H +#define ISTEAMSCREENSHOTS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +const uint32 k_nScreenshotMaxTaggedUsers = 32; +const uint32 k_nScreenshotMaxTaggedPublishedFiles = 32; +const int k_cubUFSTagTypeMax = 255; +const int k_cubUFSTagValueMax = 255; + +// Required with of a thumbnail provided to AddScreenshotToLibrary. If you do not provide a thumbnail +// one will be generated. +const int k_ScreenshotThumbWidth = 200; + +// Handle is valid for the lifetime of your process and no longer +typedef uint32 ScreenshotHandle; +#define INVALID_SCREENSHOT_HANDLE 0 + +enum EVRScreenshotType +{ + k_EVRScreenshotType_None = 0, + k_EVRScreenshotType_Mono = 1, + k_EVRScreenshotType_Stereo = 2, + k_EVRScreenshotType_MonoCubemap = 3, + k_EVRScreenshotType_MonoPanorama = 4, + k_EVRScreenshotType_StereoPanorama = 5 +}; + +//----------------------------------------------------------------------------- +// Purpose: Functions for adding screenshots to the user's screenshot library +//----------------------------------------------------------------------------- +class ISteamScreenshots +{ +public: + // Writes a screenshot to the user's screenshot library given the raw image data, which must be in RGB format. + // The return value is a handle that is valid for the duration of the game process and can be used to apply tags. + virtual ScreenshotHandle WriteScreenshot( void *pubRGB, uint32 cubRGB, int nWidth, int nHeight ) = 0; + + // Adds a screenshot to the user's screenshot library from disk. If a thumbnail is provided, it must be 200 pixels wide and the same aspect ratio + // as the screenshot, otherwise a thumbnail will be generated if the user uploads the screenshot. The screenshots must be in either JPEG or TGA format. + // The return value is a handle that is valid for the duration of the game process and can be used to apply tags. + // JPEG, TGA, and PNG formats are supported. + virtual ScreenshotHandle AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight ) = 0; + + // Causes the Steam overlay to take a screenshot. If screenshots are being hooked by the game then a ScreenshotRequested_t callback is sent back to the game instead. + virtual void TriggerScreenshot() = 0; + + // Toggles whether the overlay handles screenshots when the user presses the screenshot hotkey, or the game handles them. If the game is hooking screenshots, + // then the ScreenshotRequested_t callback will be sent if the user presses the hotkey, and the game is expected to call WriteScreenshot or AddScreenshotToLibrary + // in response. + virtual void HookScreenshots( bool bHook ) = 0; + + // Sets metadata about a screenshot's location (for example, the name of the map) + virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0; + + // Tags a user as being visible in the screenshot + virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0; + + // Tags a published file as being visible in the screenshot + virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0; + + // Returns true if the app has hooked the screenshot + virtual bool IsScreenshotsHooked() = 0; + + // Adds a VR screenshot to the user's screenshot library from disk in the supported type. + // pchFilename should be the normal 2D image used in the library view + // pchVRFilename should contain the image that matches the correct type + // The return value is a handle that is valid for the duration of the game process and can be used to apply tags. + // JPEG, TGA, and PNG formats are supported. + virtual ScreenshotHandle AddVRScreenshotToLibrary( EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename ) = 0; +}; + +#define STEAMSCREENSHOTS_INTERFACE_VERSION "STEAMSCREENSHOTS_INTERFACE_VERSION003" + +// Global interface accessor +inline ISteamScreenshots *SteamScreenshots(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamScreenshots *, SteamScreenshots, STEAMSCREENSHOTS_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif +//----------------------------------------------------------------------------- +// Purpose: Screenshot successfully written or otherwise added to the library +// and can now be tagged +//----------------------------------------------------------------------------- +struct ScreenshotReady_t +{ + enum { k_iCallback = k_iSteamScreenshotsCallbacks + 1 }; + ScreenshotHandle m_hLocal; + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// Purpose: Screenshot has been requested by the user. Only sent if +// HookScreenshots() has been called, in which case Steam will not take +// the screenshot itself. +//----------------------------------------------------------------------------- +struct ScreenshotRequested_t +{ + enum { k_iCallback = k_iSteamScreenshotsCallbacks + 2 }; +}; + +#pragma pack( pop ) + +#endif // ISTEAMSCREENSHOTS_H + diff --git a/lsteamclient/steamworks_sdk_160/isteamtimeline.h b/lsteamclient/steamworks_sdk_160/isteamtimeline.h new file mode 100644 index 0000000000..800c6bd1a8 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamtimeline.h @@ -0,0 +1,118 @@ +//====== Copyright © Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to Steam Timeline +// +//============================================================================= + +#ifndef ISTEAMTIMELINE_H +#define ISTEAMTIMELINE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +// Controls the color of the timeline bar segments. The value names listed here map to a multiplayer game, where +// the user starts a game (in menus), then joins a multiplayer session that first has a character selection lobby +// then finally the multiplayer session starts. However, you can also map these values to any type of game. In a single +// player game where you visit towns & dungeons, you could set k_ETimelineGameMode_Menus when the player is in a town +// buying items, k_ETimelineGameMode_Staging for when a dungeon is loading and k_ETimelineGameMode_Playing for when +// inside the dungeon fighting monsters. +enum ETimelineGameMode +{ + k_ETimelineGameMode_Invalid = 0, + k_ETimelineGameMode_Playing = 1, + k_ETimelineGameMode_Staging = 2, + k_ETimelineGameMode_Menus = 3, + k_ETimelineGameMode_LoadingScreen = 4, + + k_ETimelineGameMode_Max, // one past the last valid value +}; + +// Used in AddTimelineEvent, where Featured events will be offered before Standard events +enum ETimelineEventClipPriority +{ + k_ETimelineEventClipPriority_Invalid = 0, + k_ETimelineEventClipPriority_None = 1, + k_ETimelineEventClipPriority_Standard = 2, + k_ETimelineEventClipPriority_Featured = 3, +}; + +const uint32 k_unMaxTimelinePriority = 1000; +const float k_flMaxTimelineEventDuration = 600.f; + +//----------------------------------------------------------------------------- +// Purpose: Steam Timeline API +//----------------------------------------------------------------------------- +class ISteamTimeline +{ +public: + + // Sets a description for the current game state in the timeline. These help the user to find specific + // moments in the timeline when saving clips. Setting a new state description replaces any previous + // description. + // + // Examples could include: + // * Where the user is in the world in a single player game + // * Which round is happening in a multiplayer game + // * The current score for a sports game + // + // Parameters: + // - pchDescription: provide a localized string in the language returned by SteamUtils()->GetSteamUILanguage() + // - flTimeDelta: The time offset in seconds to apply to this event. Negative times indicate an + // event that happened in the past. + virtual void SetTimelineStateDescription( const char *pchDescription, float flTimeDelta ) = 0; + virtual void ClearTimelineStateDescription( float flTimeDelta ) = 0; + + // Use this to mark an event on the Timeline. The event can be instantaneous or take some amount of time + // to complete, depending on the value passed in flDurationSeconds + // + // Examples could include: + // * a boss battle + // * a cut scene + // * a large team fight + // * picking up a new weapon or ammunition + // * scoring a goal + // + // Parameters: + // + // - pchIcon: specify the name of the icon uploaded through the Steamworks Partner Site for your title + // or one of the provided icons that start with steam_ + // - pchTitle & pchDescription: provide a localized string in the language returned by + // SteamUtils()->GetSteamUILanguage() + // - unPriority: specify how important this range is compared to other markers provided by the game. + // Ranges with larger priority values will be displayed more prominently in the UI. This value + // may be between 0 and k_unMaxTimelinePriority. + // - flStartOffsetSeconds: The time that this range started relative to now. Negative times + // indicate an event that happened in the past. + // - flDurationSeconds: How long the time range should be in seconds. For instantaneous events, this + // should be 0 + // - ePossibleClip: By setting this parameter to Featured or Standard, the game indicates to Steam that it + // would be appropriate to offer this range as a clip to the user. For instantaneous events, the + // suggested clip will be for a short time before and after the event itself. + virtual void AddTimelineEvent( const char *pchIcon, const char *pchTitle, const char *pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip ) = 0; + + // Changes the color of the timeline bar. See ETimelineGameMode comments for how to use each value + virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0; +}; + +#define STEAMTIMELINE_INTERFACE_VERSION "STEAMTIMELINE_INTERFACE_V001" + +// Global interface accessor +inline ISteamTimeline *SteamTimeline(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamTimeline *, SteamTimeline, STEAMTIMELINE_INTERFACE_VERSION ); + + +#pragma pack( pop ) + + +#endif // ISTEAMTIMELINE_H diff --git a/lsteamclient/steamworks_sdk_160/isteamugc.h b/lsteamclient/steamworks_sdk_160/isteamugc.h new file mode 100644 index 0000000000..40c5947b56 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamugc.h @@ -0,0 +1,632 @@ +//====== Copyright 1996-2013, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to steam ugc +// +//============================================================================= + +#ifndef ISTEAMUGC_H +#define ISTEAMUGC_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "isteamremotestorage.h" + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +typedef uint64 UGCQueryHandle_t; +typedef uint64 UGCUpdateHandle_t; + + +const UGCQueryHandle_t k_UGCQueryHandleInvalid = 0xffffffffffffffffull; +const UGCUpdateHandle_t k_UGCUpdateHandleInvalid = 0xffffffffffffffffull; + + +// Matching UGC types for queries +enum EUGCMatchingUGCType +{ + k_EUGCMatchingUGCType_Items = 0, // both mtx items and ready-to-use items + k_EUGCMatchingUGCType_Items_Mtx = 1, + k_EUGCMatchingUGCType_Items_ReadyToUse = 2, + k_EUGCMatchingUGCType_Collections = 3, + k_EUGCMatchingUGCType_Artwork = 4, + k_EUGCMatchingUGCType_Videos = 5, + k_EUGCMatchingUGCType_Screenshots = 6, + k_EUGCMatchingUGCType_AllGuides = 7, // both web guides and integrated guides + k_EUGCMatchingUGCType_WebGuides = 8, + k_EUGCMatchingUGCType_IntegratedGuides = 9, + k_EUGCMatchingUGCType_UsableInGame = 10, // ready-to-use items and integrated guides + k_EUGCMatchingUGCType_ControllerBindings = 11, + k_EUGCMatchingUGCType_GameManagedItems = 12, // game managed items (not managed by users) + k_EUGCMatchingUGCType_All = ~0, // @note: will only be valid for CreateQueryUserUGCRequest requests +}; + +// Different lists of published UGC for a user. +// If the current logged in user is different than the specified user, then some options may not be allowed. +enum EUserUGCList +{ + k_EUserUGCList_Published, + k_EUserUGCList_VotedOn, + k_EUserUGCList_VotedUp, + k_EUserUGCList_VotedDown, + k_EUserUGCList_WillVoteLater, + k_EUserUGCList_Favorited, + k_EUserUGCList_Subscribed, + k_EUserUGCList_UsedOrPlayed, + k_EUserUGCList_Followed, +}; + +// Sort order for user published UGC lists (defaults to creation order descending) +enum EUserUGCListSortOrder +{ + k_EUserUGCListSortOrder_CreationOrderDesc, + k_EUserUGCListSortOrder_CreationOrderAsc, + k_EUserUGCListSortOrder_TitleAsc, + k_EUserUGCListSortOrder_LastUpdatedDesc, + k_EUserUGCListSortOrder_SubscriptionDateDesc, + k_EUserUGCListSortOrder_VoteScoreDesc, + k_EUserUGCListSortOrder_ForModeration, +}; + +// Combination of sorting and filtering for queries across all UGC +enum EUGCQuery +{ + k_EUGCQuery_RankedByVote = 0, + k_EUGCQuery_RankedByPublicationDate = 1, + k_EUGCQuery_AcceptedForGameRankedByAcceptanceDate = 2, + k_EUGCQuery_RankedByTrend = 3, + k_EUGCQuery_FavoritedByFriendsRankedByPublicationDate = 4, + k_EUGCQuery_CreatedByFriendsRankedByPublicationDate = 5, + k_EUGCQuery_RankedByNumTimesReported = 6, + k_EUGCQuery_CreatedByFollowedUsersRankedByPublicationDate = 7, + k_EUGCQuery_NotYetRated = 8, + k_EUGCQuery_RankedByTotalVotesAsc = 9, + k_EUGCQuery_RankedByVotesUp = 10, + k_EUGCQuery_RankedByTextSearch = 11, + k_EUGCQuery_RankedByTotalUniqueSubscriptions = 12, + k_EUGCQuery_RankedByPlaytimeTrend = 13, + k_EUGCQuery_RankedByTotalPlaytime = 14, + k_EUGCQuery_RankedByAveragePlaytimeTrend = 15, + k_EUGCQuery_RankedByLifetimeAveragePlaytime = 16, + k_EUGCQuery_RankedByPlaytimeSessionsTrend = 17, + k_EUGCQuery_RankedByLifetimePlaytimeSessions = 18, + k_EUGCQuery_RankedByLastUpdatedDate = 19, +}; + +enum EItemUpdateStatus +{ + k_EItemUpdateStatusInvalid = 0, // The item update handle was invalid, job might be finished, listen too SubmitItemUpdateResult_t + k_EItemUpdateStatusPreparingConfig = 1, // The item update is processing configuration data + k_EItemUpdateStatusPreparingContent = 2, // The item update is reading and processing content files + k_EItemUpdateStatusUploadingContent = 3, // The item update is uploading content changes to Steam + k_EItemUpdateStatusUploadingPreviewFile = 4, // The item update is uploading new preview file image + k_EItemUpdateStatusCommittingChanges = 5 // The item update is committing all changes +}; + +enum EItemState +{ + k_EItemStateNone = 0, // item not tracked on client + k_EItemStateSubscribed = 1, // current user is subscribed to this item. Not just cached. + k_EItemStateLegacyItem = 2, // item was created with ISteamRemoteStorage + k_EItemStateInstalled = 4, // item is installed and usable (but maybe out of date) + k_EItemStateNeedsUpdate = 8, // items needs an update. Either because it's not installed yet or creator updated content + k_EItemStateDownloading = 16, // item update is currently downloading + k_EItemStateDownloadPending = 32, // DownloadItem() was called for this item, content isn't available until DownloadItemResult_t is fired + k_EItemStateDisabledLocally = 64, // Item is disabled locally, so it shouldn't be considered subscribed +}; + +enum EItemStatistic +{ + k_EItemStatistic_NumSubscriptions = 0, + k_EItemStatistic_NumFavorites = 1, + k_EItemStatistic_NumFollowers = 2, + k_EItemStatistic_NumUniqueSubscriptions = 3, + k_EItemStatistic_NumUniqueFavorites = 4, + k_EItemStatistic_NumUniqueFollowers = 5, + k_EItemStatistic_NumUniqueWebsiteViews = 6, + k_EItemStatistic_ReportScore = 7, + k_EItemStatistic_NumSecondsPlayed = 8, + k_EItemStatistic_NumPlaytimeSessions = 9, + k_EItemStatistic_NumComments = 10, + k_EItemStatistic_NumSecondsPlayedDuringTimePeriod = 11, + k_EItemStatistic_NumPlaytimeSessionsDuringTimePeriod = 12, +}; + +enum EItemPreviewType +{ + k_EItemPreviewType_Image = 0, // standard image file expected (e.g. jpg, png, gif, etc.) + k_EItemPreviewType_YouTubeVideo = 1, // video id is stored + k_EItemPreviewType_Sketchfab = 2, // model id is stored + k_EItemPreviewType_EnvironmentMap_HorizontalCross = 3, // standard image file expected - cube map in the layout + // +---+---+-------+ + // | |Up | | + // +---+---+---+---+ + // | L | F | R | B | + // +---+---+---+---+ + // | |Dn | | + // +---+---+---+---+ + k_EItemPreviewType_EnvironmentMap_LatLong = 4, // standard image file expected + k_EItemPreviewType_Clip = 5, // clip id is stored + k_EItemPreviewType_ReservedMax = 255, // you can specify your own types above this value +}; + +enum EUGCContentDescriptorID +{ + k_EUGCContentDescriptor_NudityOrSexualContent = 1, + k_EUGCContentDescriptor_FrequentViolenceOrGore = 2, + k_EUGCContentDescriptor_AdultOnlySexualContent = 3, + k_EUGCContentDescriptor_GratuitousSexualContent = 4, + k_EUGCContentDescriptor_AnyMatureContent = 5, +}; + +const uint32 kNumUGCResultsPerPage = 50; +const uint32 k_cchDeveloperMetadataMax = 5000; + +// Details for a single published file/UGC +struct SteamUGCDetails_t +{ + PublishedFileId_t m_nPublishedFileId; + EResult m_eResult; // The result of the operation. + EWorkshopFileType m_eFileType; // Type of the file + AppId_t m_nCreatorAppID; // ID of the app that created this file. + AppId_t m_nConsumerAppID; // ID of the app that will consume this file. + char m_rgchTitle[k_cchPublishedDocumentTitleMax]; // title of document + char m_rgchDescription[k_cchPublishedDocumentDescriptionMax]; // description of document + uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content. + uint32 m_rtimeCreated; // time when the published file was created + uint32 m_rtimeUpdated; // time when the published file was last updated + uint32 m_rtimeAddedToUserList; // time when the user added the published file to their list (not always applicable) + ERemoteStoragePublishedFileVisibility m_eVisibility; // visibility + bool m_bBanned; // whether the file was banned + bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop + bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer + char m_rgchTags[k_cchTagListMax]; // comma separated list of all tags associated with this file + // file/url information + UGCHandle_t m_hFile; // The handle of the primary file + UGCHandle_t m_hPreviewFile; // The handle of the preview file + char m_pchFileName[k_cchFilenameMax]; // The cloud filename of the primary file + int32 m_nFileSize; // Size of the primary file (for legacy items which only support one file). This may not be accurate for non-legacy items which can be greater than 4gb in size. + int32 m_nPreviewFileSize; // Size of the preview file + char m_rgchURL[k_cchPublishedFileURLMax]; // URL (for a video or a website) + // voting information + uint32 m_unVotesUp; // number of votes up + uint32 m_unVotesDown; // number of votes down + float m_flScore; // calculated score + // collection details + uint32 m_unNumChildren; + uint64 m_ulTotalFilesSize; // Total size of all files (non-legacy), excluding the preview file +}; + +//----------------------------------------------------------------------------- +// Purpose: Steam UGC support API +//----------------------------------------------------------------------------- +class ISteamUGC +{ +public: + + // Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1. + virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0; + + // Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1. + STEAM_FLAT_NAME( CreateQueryAllUGCRequestPage ) + virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0; + + // Query for all matching UGC using the new deep paging interface. Creator app id or consumer app id must be valid and be set to the current running app. pchCursor should be set to NULL or "*" to get the first result set. + STEAM_FLAT_NAME( CreateQueryAllUGCRequestCursor ) + virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char *pchCursor = NULL ) = 0; + + // Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this) + virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0; + + // Send the query to Steam + STEAM_CALL_RESULT( SteamUGCQueryCompleted_t ) + virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0; + + // Retrieve an individual result after receiving the callback for querying UGC + virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0; + virtual uint32 GetQueryUGCNumTags( UGCQueryHandle_t handle, uint32 index ) = 0; + virtual bool GetQueryUGCTag( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0; + virtual bool GetQueryUGCTagDisplayName( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0; + virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize ) = 0; + virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchMetadatasize) char *pchMetadata, uint32 cchMetadatasize ) = 0; + virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; + virtual bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 *pStatValue ) = 0; + virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0; + virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType ) = 0; + virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0; + virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, STEAM_OUT_STRING_COUNT(cchKeySize) char *pchKey, uint32 cchKeySize, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0; + + // Return the first value matching the pchKey. Note that a key may map to multiple values. Returns false if there was an error or no matching value was found. + STEAM_FLAT_NAME( GetQueryFirstUGCKeyValueTag ) + virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *pchKey, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0; + + // Some items can specify that they have a version that is valid for a range of game versions (Steam branch) + virtual uint32 GetNumSupportedGameVersions( UGCQueryHandle_t handle, uint32 index ) = 0; + virtual bool GetSupportedGameVersionData( UGCQueryHandle_t handle, uint32 index, uint32 versionIndex, STEAM_OUT_STRING_COUNT( cchGameBranchSize ) char *pchGameBranchMin, STEAM_OUT_STRING_COUNT( cchGameBranchSize ) char *pchGameBranchMax, uint32 cchGameBranchSize ) = 0; + + virtual uint32 GetQueryUGCContentDescriptors( UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0; + + // Release the request to free up memory, after retrieving results + virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0; + + // Options to set for querying UGC + virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0; + virtual bool AddRequiredTagGroup( UGCQueryHandle_t handle, const SteamParamStringArray_t *pTagGroups ) = 0; // match any of the tags in this group + virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0; + virtual bool SetReturnOnlyIDs( UGCQueryHandle_t handle, bool bReturnOnlyIDs ) = 0; + virtual bool SetReturnKeyValueTags( UGCQueryHandle_t handle, bool bReturnKeyValueTags ) = 0; + virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0; + virtual bool SetReturnMetadata( UGCQueryHandle_t handle, bool bReturnMetadata ) = 0; + virtual bool SetReturnChildren( UGCQueryHandle_t handle, bool bReturnChildren ) = 0; + virtual bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ) = 0; + virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0; + virtual bool SetReturnPlaytimeStats( UGCQueryHandle_t handle, uint32 unDays ) = 0; + virtual bool SetLanguage( UGCQueryHandle_t handle, const char *pchLanguage ) = 0; + virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0; + virtual bool SetAdminQuery( UGCUpdateHandle_t handle, bool bAdminQuery ) = 0; // admin queries return hidden items + + // Options only for querying user UGC + virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0; + + // Options only for querying all UGC + virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0; + virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0; + virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0; + virtual bool SetTimeCreatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0; + virtual bool SetTimeUpdatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0; + virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0; + + // DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead! + STEAM_CALL_RESULT( SteamUGCRequestUGCDetailsResult_t ) + virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0; + + // Steam Workshop Creator API + STEAM_CALL_RESULT( CreateItemResult_t ) + virtual SteamAPICall_t CreateItem( AppId_t nConsumerAppId, EWorkshopFileType eFileType ) = 0; // create new item for this app with no content attached yet + + virtual UGCUpdateHandle_t StartItemUpdate( AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ) = 0; // start an UGC item update. Set changed properties before commiting update with CommitItemUpdate() + + virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item + virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item + virtual bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, const char *pchLanguage ) = 0; // specify the language of the title or description that will be set + virtual bool SetItemMetadata( UGCUpdateHandle_t handle, const char *pchMetaData ) = 0; // change the metadata of an UGC item (max = k_cchDeveloperMetadataMax) + virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item + virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags, bool bAllowAdminTags = false ) = 0; // change the tags of an UGC item + virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder + virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; // change preview image file for this item. pszPreviewFile points to local image file, which must be under 1MB in size + virtual bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, bool bAllowLegacyUpload ) = 0; // use legacy upload for a single small file. The parameter to SetItemContent() should either be a directory with one file or the full path to the file. The file must also be less than 10MB in size. + virtual bool RemoveAllItemKeyValueTags( UGCUpdateHandle_t handle ) = 0; // remove all existing key-value tags (you can add new ones via the AddItemKeyValueTag function) + virtual bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey ) = 0; // remove any existing key-value tags with the specified key + virtual bool AddItemKeyValueTag( UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue ) = 0; // add new key-value tags for the item. Note that there can be multiple values for a tag. + virtual bool AddItemPreviewFile( UGCUpdateHandle_t handle, const char *pszPreviewFile, EItemPreviewType type ) = 0; // add preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size + virtual bool AddItemPreviewVideo( UGCUpdateHandle_t handle, const char *pszVideoID ) = 0; // add preview video for this item + virtual bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile ) = 0; // updates an existing preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size + virtual bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID ) = 0; // updates an existing preview video for this item + virtual bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index ) = 0; // remove a preview by index starting at 0 (previews are sorted) + virtual bool AddContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ) = 0; + virtual bool RemoveContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ) = 0; + virtual bool SetRequiredGameVersions( UGCUpdateHandle_t handle, const char *pszGameBranchMin, const char *pszGameBranchMax ) = 0; // an empty string for either parameter means that it will match any version on that end of the range. This will only be applied if the actual content has been changed. + + STEAM_CALL_RESULT( SubmitItemUpdateResult_t ) + virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate() + virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0; + + // Steam Workshop Consumer API + STEAM_CALL_RESULT( SetUserItemVoteResult_t ) + virtual SteamAPICall_t SetUserItemVote( PublishedFileId_t nPublishedFileID, bool bVoteUp ) = 0; + STEAM_CALL_RESULT( GetUserItemVoteResult_t ) + virtual SteamAPICall_t GetUserItemVote( PublishedFileId_t nPublishedFileID ) = 0; + STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t ) + virtual SteamAPICall_t AddItemToFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0; + STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t ) + virtual SteamAPICall_t RemoveItemFromFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0; + STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t ) + virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscribe to this item, will be installed ASAP + STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t ) + virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits + virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items + virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs + + // get EItemState flags about item on this client + virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0; + + // get info about currently installed content on disc for items that have k_EItemStateInstalled set + // if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder) + virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, STEAM_OUT_STRING_COUNT( cchFolderSize ) char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp ) = 0; + + // get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once + virtual bool GetItemDownloadInfo( PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0; + + // download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed, + // then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time. + // If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP. + virtual bool DownloadItem( PublishedFileId_t nPublishedFileID, bool bHighPriority ) = 0; + + // game servers can set a specific workshop folder before issuing any UGC commands. + // This is helpful if you want to support multiple game servers running out of the same install folder + virtual bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, const char *pszFolder ) = 0; + + // SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends + virtual void SuspendDownloads( bool bSuspend ) = 0; + + // usage tracking + STEAM_CALL_RESULT( StartPlaytimeTrackingResult_t ) + virtual SteamAPICall_t StartPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0; + STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t ) + virtual SteamAPICall_t StopPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0; + STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t ) + virtual SteamAPICall_t StopPlaytimeTrackingForAllItems() = 0; + + // parent-child relationship or dependency management + STEAM_CALL_RESULT( AddUGCDependencyResult_t ) + virtual SteamAPICall_t AddDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0; + STEAM_CALL_RESULT( RemoveUGCDependencyResult_t ) + virtual SteamAPICall_t RemoveDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0; + + // add/remove app dependence/requirements (usually DLC) + STEAM_CALL_RESULT( AddAppDependencyResult_t ) + virtual SteamAPICall_t AddAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0; + STEAM_CALL_RESULT( RemoveAppDependencyResult_t ) + virtual SteamAPICall_t RemoveAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0; + // request app dependencies. note that whatever callback you register for GetAppDependenciesResult_t may be called multiple times + // until all app dependencies have been returned + STEAM_CALL_RESULT( GetAppDependenciesResult_t ) + virtual SteamAPICall_t GetAppDependencies( PublishedFileId_t nPublishedFileID ) = 0; + + // delete the item without prompting the user + STEAM_CALL_RESULT( DeleteItemResult_t ) + virtual SteamAPICall_t DeleteItem( PublishedFileId_t nPublishedFileID ) = 0; + + // Show the app's latest Workshop EULA to the user in an overlay window, where they can accept it or not + virtual bool ShowWorkshopEULA() = 0; + // Retrieve information related to the user's acceptance or not of the app's specific Workshop EULA + STEAM_CALL_RESULT( WorkshopEULAStatus_t ) + virtual SteamAPICall_t GetWorkshopEULAStatus() = 0; + + // Return the user's community content descriptor preferences + virtual uint32 GetUserContentDescriptorPreferences( EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0; +}; + +#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION020" + +// Global interface accessor +inline ISteamUGC *SteamUGC(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUGC *, SteamUGC, STEAMUGC_INTERFACE_VERSION ); + +// Global accessor for the gameserver client +inline ISteamUGC *SteamGameServerUGC(); +STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamUGC *, SteamGameServerUGC, STEAMUGC_INTERFACE_VERSION ); + +//----------------------------------------------------------------------------- +// Purpose: Callback for querying UGC +//----------------------------------------------------------------------------- +struct SteamUGCQueryCompleted_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 1 }; + UGCQueryHandle_t m_handle; + EResult m_eResult; + uint32 m_unNumResultsReturned; + uint32 m_unTotalMatchingResults; + bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache + char m_rgchNextCursor[k_cchPublishedFileURLMax]; // If a paging cursor was used, then this will be the next cursor to get the next result set. +}; + + +//----------------------------------------------------------------------------- +// Purpose: Callback for requesting details on one piece of UGC +//----------------------------------------------------------------------------- +struct SteamUGCRequestUGCDetailsResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 2 }; + SteamUGCDetails_t m_details; + bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache +}; + + +//----------------------------------------------------------------------------- +// Purpose: result for ISteamUGC::CreateItem() +//----------------------------------------------------------------------------- +struct CreateItemResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 3 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; // new item got this UGC PublishFileID + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; +}; + + +//----------------------------------------------------------------------------- +// Purpose: result for ISteamUGC::SubmitItemUpdate() +//----------------------------------------------------------------------------- +struct SubmitItemUpdateResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 4 }; + EResult m_eResult; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + PublishedFileId_t m_nPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: a Workshop item has been installed or updated +//----------------------------------------------------------------------------- +struct ItemInstalled_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 5 }; + AppId_t m_unAppID; + PublishedFileId_t m_nPublishedFileId; + UGCHandle_t m_hLegacyContent; + uint64 m_unManifestID; +}; + + +//----------------------------------------------------------------------------- +// Purpose: result of DownloadItem(), existing item files can be accessed again +//----------------------------------------------------------------------------- +struct DownloadItemResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 6 }; + AppId_t m_unAppID; + PublishedFileId_t m_nPublishedFileId; + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// Purpose: result of AddItemToFavorites() or RemoveItemFromFavorites() +//----------------------------------------------------------------------------- +struct UserFavoriteItemsListChanged_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 7 }; + PublishedFileId_t m_nPublishedFileId; + EResult m_eResult; + bool m_bWasAddRequest; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to SetUserItemVote() +//----------------------------------------------------------------------------- +struct SetUserItemVoteResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 8 }; + PublishedFileId_t m_nPublishedFileId; + EResult m_eResult; + bool m_bVoteUp; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to GetUserItemVote() +//----------------------------------------------------------------------------- +struct GetUserItemVoteResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 9 }; + PublishedFileId_t m_nPublishedFileId; + EResult m_eResult; + bool m_bVotedUp; + bool m_bVotedDown; + bool m_bVoteSkipped; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to StartPlaytimeTracking() +//----------------------------------------------------------------------------- +struct StartPlaytimeTrackingResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 10 }; + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to StopPlaytimeTracking() +//----------------------------------------------------------------------------- +struct StopPlaytimeTrackingResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 11 }; + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to AddDependency +//----------------------------------------------------------------------------- +struct AddUGCDependencyResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 12 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; + PublishedFileId_t m_nChildPublishedFileId; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to RemoveDependency +//----------------------------------------------------------------------------- +struct RemoveUGCDependencyResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 13 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; + PublishedFileId_t m_nChildPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to AddAppDependency +//----------------------------------------------------------------------------- +struct AddAppDependencyResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 14 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; + AppId_t m_nAppID; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to RemoveAppDependency +//----------------------------------------------------------------------------- +struct RemoveAppDependencyResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 15 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; + AppId_t m_nAppID; +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to GetAppDependencies. Callback may be called +// multiple times until all app dependencies have been returned. +//----------------------------------------------------------------------------- +struct GetAppDependenciesResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 16 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; + AppId_t m_rgAppIDs[32]; + uint32 m_nNumAppDependencies; // number returned in this struct + uint32 m_nTotalNumAppDependencies; // total found +}; + +//----------------------------------------------------------------------------- +// Purpose: The result of a call to DeleteItem +//----------------------------------------------------------------------------- +struct DeleteItemResult_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 17 }; + EResult m_eResult; + PublishedFileId_t m_nPublishedFileId; +}; + + +//----------------------------------------------------------------------------- +// Purpose: signal that the list of subscribed items changed +//----------------------------------------------------------------------------- +struct UserSubscribedItemsListChanged_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 18 }; + AppId_t m_nAppID; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Status of the user's acceptable/rejection of the app's specific Workshop EULA +//----------------------------------------------------------------------------- +struct WorkshopEULAStatus_t +{ + enum { k_iCallback = k_iSteamUGCCallbacks + 20 }; + EResult m_eResult; + AppId_t m_nAppID; + uint32 m_unVersion; + RTime32 m_rtAction; + bool m_bAccepted; + bool m_bNeedsAction; +}; + +#pragma pack( pop ) + +#endif // ISTEAMUGC_H diff --git a/lsteamclient/steamworks_sdk_160/isteamuser.h b/lsteamclient/steamworks_sdk_160/isteamuser.h new file mode 100644 index 0000000000..182f02e7c3 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamuser.h @@ -0,0 +1,439 @@ +//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to user account information in Steam +// +//============================================================================= + +#ifndef ISTEAMUSER_H +#define ISTEAMUSER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +//----------------------------------------------------------------------------- +// Purpose: Functions for accessing and manipulating a steam account +// associated with one client instance +//----------------------------------------------------------------------------- +class ISteamUser +{ +public: + // returns the HSteamUser this interface represents + // this is only used internally by the API, and by a few select interfaces that support multi-user + virtual HSteamUser GetHSteamUser() = 0; + + // returns true if the Steam client current has a live connection to the Steam servers. + // If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy. + // The Steam client will automatically be trying to recreate the connection as often as possible. + virtual bool BLoggedOn() = 0; + + // returns the CSteamID of the account currently logged into the Steam client + // a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API + virtual CSteamID GetSteamID() = 0; + + // Multiplayer Authentication functions + + // InitiateGameConnection() starts the state machine for authenticating the game client with the game server + // It is the client portion of a three-way handshake between the client, the game server, and the steam servers + // + // Parameters: + // void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token. + // int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes. + // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client + // CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( ) + // uint32 unIPServer, uint16 usPortServer - the IP address of the game server + // bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running) + // + // return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed + // The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process. + // + // DEPRECATED! This function will be removed from the SDK in an upcoming version. + // Please migrate to BeginAuthSession and related functions. + virtual int InitiateGameConnection_DEPRECATED( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0; + + // notify of disconnect + // needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call + // + // DEPRECATED! This function will be removed from the SDK in an upcoming version. + // Please migrate to BeginAuthSession and related functions. + virtual void TerminateGameConnection_DEPRECATED( uint32 unIPServer, uint16 usPortServer ) = 0; + + // Legacy functions + + // used by only a few games to track usage events + virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0; + + // get the local storage folder for current Steam account to write application data, e.g. save games, configs etc. + // this will usually be something like "C:\Progam Files\Steam\userdata\\\local" + virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0; + + // Starts voice recording. Once started, use GetVoice() to get the data + virtual void StartVoiceRecording( ) = 0; + + // Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for + // a little bit after this function is called. GetVoice() should continue to be called until it returns + // k_eVoiceResultNotRecording + virtual void StopVoiceRecording( ) = 0; + + // Determine the size of captured audio data that is available from GetVoice. + // Most applications will only use compressed data and should ignore the other + // parameters, which exist primarily for backwards compatibility. See comments + // below for further explanation of "uncompressed" data. + virtual EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0; + + // --------------------------------------------------------------------------- + // NOTE: "uncompressed" audio is a deprecated feature and should not be used + // by most applications. It is raw single-channel 16-bit PCM wave data which + // may have been run through preprocessing filters and/or had silence removed, + // so the uncompressed audio could have a shorter duration than you expect. + // There may be no data at all during long periods of silence. Also, fetching + // uncompressed audio will cause GetVoice to discard any leftover compressed + // audio, so you must fetch both types at once. Finally, GetAvailableVoice is + // not precisely accurate when the uncompressed size is requested. So if you + // really need to use uncompressed audio, you should call GetVoice frequently + // with two very large (20kb+) output buffers instead of trying to allocate + // perfectly-sized buffers. But most applications should ignore all of these + // details and simply leave the "uncompressed" parameters as NULL/zero. + // --------------------------------------------------------------------------- + + // Read captured audio data from the microphone buffer. This should be called + // at least once per frame, and preferably every few milliseconds, to keep the + // microphone input delay as low as possible. Most applications will only use + // compressed data and should pass NULL/zero for the "uncompressed" parameters. + // Compressed data can be transmitted by your application and decoded into raw + // using the DecompressVoice function below. + virtual EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated = false, void *pUncompressedDestBuffer_Deprecated = 0, uint32 cbUncompressedDestBufferSize_Deprecated = 0, uint32 *nUncompressBytesWritten_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0; + + // Decodes the compressed voice data returned by GetVoice. The output data is + // raw single-channel 16-bit PCM audio. The decoder supports any sample rate + // from 11025 to 48000; see GetVoiceOptimalSampleRate() below for details. + // If the output buffer is not large enough, then *nBytesWritten will be set + // to the required buffer size, and k_EVoiceResultBufferTooSmall is returned. + // It is suggested to start with a 20kb buffer and reallocate as necessary. + virtual EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) = 0; + + // This returns the native sample rate of the Steam voice decompressor; using + // this sample rate for DecompressVoice will perform the least CPU processing. + // However, the final audio quality will depend on how well the audio device + // (and/or your application's audio output SDK) deals with lower sample rates. + // You may find that you get the best audio output quality when you ignore + // this function and use the native sample rate of your audio output device, + // which is usually 48000 or 44100. + virtual uint32 GetVoiceOptimalSampleRate() = 0; + + // Retrieve ticket to be sent to the entity who wishes to authenticate you. + // pcbTicket retrieves the length of the actual ticket. + // SteamNetworkingIdentity is an optional input parameter to hold the public IP address or SteamID of the entity you are connecting to + // if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address + // if a Steam ID is passed Steam will only allow the ticket to be used by that Steam ID + // not to be used for "ISteamUserAuth\AuthenticateUserTicket" - it will fail + virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity ) = 0; + + // Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket" + // pchIdentity is an optional input parameter to identify the service the ticket will be sent to + // the ticket will be returned in callback GetTicketForWebApiResponse_t + virtual HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity ) = 0; + + // Authenticate ticket from entity steamID to be sure it is valid and isnt reused + // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse ) + virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0; + + // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity + virtual void EndAuthSession( CSteamID steamID ) = 0; + + // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to + virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0; + + // After receiving a user's authentication data, and passing it to BeginAuthSession, use this function + // to determine if the user owns downloadable content specified by the provided AppID. + virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0; + + // returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam + // (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT. + virtual bool BIsBehindNAT() = 0; + + // set data to be replicated to friends so that they can join your game + // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client + // uint32 unIPServer, uint16 usPortServer - the IP address of the game server + virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0; + + // Requests a ticket encrypted with an app specific shared key + // pDataToInclude, cbDataToInclude will be encrypted into the ticket + // ( This is asynchronous, you must wait for the ticket to be completed by the server ) + STEAM_CALL_RESULT( EncryptedAppTicketResponse_t ) + virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0; + + // Retrieves a finished ticket. + // If no ticket is available, or your buffer is too small, returns false. + // Upon exit, *pcbTicket will be either the size of the ticket copied into your buffer + // (if true was returned), or the size needed (if false was returned). To determine the + // proper size of the ticket, you can pass pTicket=NULL and cbMaxTicket=0; if a ticket + // is available, *pcbTicket will contain the size needed, otherwise it will be zero. + virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0; + + // Trading Card badges data access + // if you only have one set of cards, the series will be 1 + // the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1) + virtual int GetGameBadgeLevel( int nSeries, bool bFoil ) = 0; + + // gets the Steam Level of the user, as shown on their profile + virtual int GetPlayerSteamLevel() = 0; + + // Requests a URL which authenticates an in-game browser for store check-out, + // and then redirects to the specified URL. As long as the in-game browser + // accepts and handles session cookies, Steam microtransaction checkout pages + // will automatically recognize the user instead of presenting a login page. + // The result of this API call will be a StoreAuthURLResponse_t callback. + // NOTE: The URL has a very short lifetime to prevent history-snooping attacks, + // so you should only call this API when you are about to launch the browser, + // or else immediately navigate to the result URL using a hidden browser window. + // NOTE 2: The resulting authorization cookie has an expiration time of one day, + // so it would be a good idea to request and visit a new auth URL every 12 hours. + STEAM_CALL_RESULT( StoreAuthURLResponse_t ) + virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0; + + // gets whether the users phone number is verified + virtual bool BIsPhoneVerified() = 0; + + // gets whether the user has two factor enabled on their account + virtual bool BIsTwoFactorEnabled() = 0; + + // gets whether the users phone number is identifying + virtual bool BIsPhoneIdentifying() = 0; + + // gets whether the users phone number is awaiting (re)verification + virtual bool BIsPhoneRequiringVerification() = 0; + + STEAM_CALL_RESULT( MarketEligibilityResponse_t ) + virtual SteamAPICall_t GetMarketEligibility() = 0; + + // Retrieves anti indulgence / duration control for current user + STEAM_CALL_RESULT( DurationControl_t ) + virtual SteamAPICall_t GetDurationControl() = 0; + + // Advise steam china duration control system about the online state of the game. + // This will prevent offline gameplay time from counting against a user's + // playtime limits. + virtual bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) = 0; + +}; + +#define STEAMUSER_INTERFACE_VERSION "SteamUser023" + +// Global interface accessor +inline ISteamUser *SteamUser(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUser *, SteamUser, STEAMUSER_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + + +//----------------------------------------------------------------------------- +// Purpose: Called when an authenticated connection to the Steam back-end has been established. +// This means the Steam client now has a working connection to the Steam servers. +// Usually this will have occurred before the game has launched, and should +// only be seen if the user has dropped connection due to a networking issue +// or a Steam server update. +//----------------------------------------------------------------------------- +struct SteamServersConnected_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 1 }; +}; + +//----------------------------------------------------------------------------- +// Purpose: called when a connection attempt has failed +// this will occur periodically if the Steam client is not connected, +// and has failed in it's retry to establish a connection +//----------------------------------------------------------------------------- +struct SteamServerConnectFailure_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 2 }; + EResult m_eResult; + bool m_bStillRetrying; +}; + + +//----------------------------------------------------------------------------- +// Purpose: called if the client has lost connection to the Steam servers +// real-time services will be disabled until a matching SteamServersConnected_t has been posted +//----------------------------------------------------------------------------- +struct SteamServersDisconnected_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 3 }; + EResult m_eResult; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server, +// which it may be in the process of or already connected to. +// The game client should immediately disconnect upon receiving this message. +// This can usually occur if the user doesn't have rights to play on the game server. +//----------------------------------------------------------------------------- +struct ClientGameServerDeny_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 13 }; + + uint32 m_uAppID; + uint32 m_unGameServerIP; + uint16 m_usGameServerPort; + uint16 m_bSecure; + uint32 m_uReason; +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks) +// When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect. +// This usually occurs in the rare event the Steam client has some kind of fatal error. +//----------------------------------------------------------------------------- +struct IPCFailure_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 17 }; + enum EFailureType + { + k_EFailureFlushedCallbackQueue, + k_EFailurePipeFail, + }; + uint8 m_eFailureType; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Signaled whenever licenses change +//----------------------------------------------------------------------------- +struct LicensesUpdated_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 25 }; +}; + + +//----------------------------------------------------------------------------- +// callback for BeginAuthSession +//----------------------------------------------------------------------------- +struct ValidateAuthTicketResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 43 }; + CSteamID m_SteamID; + EAuthSessionResponse m_eAuthSessionResponse; + CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when a user has responded to a microtransaction authorization request +//----------------------------------------------------------------------------- +struct MicroTxnAuthorizationResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 52 }; + + uint32 m_unAppID; // AppID for this microtransaction + uint64 m_ulOrderID; // OrderID provided for the microtransaction + uint8 m_bAuthorized; // if user authorized transaction +}; + + +//----------------------------------------------------------------------------- +// Purpose: Result from RequestEncryptedAppTicket +//----------------------------------------------------------------------------- +struct EncryptedAppTicketResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 54 }; + + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// callback for GetAuthSessionTicket +//----------------------------------------------------------------------------- +struct GetAuthSessionTicketResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 63 }; + HAuthTicket m_hAuthTicket; + EResult m_eResult; +}; + +//----------------------------------------------------------------------------- +// Purpose: sent to your game in response to a steam://gamewebcallback/ command +//----------------------------------------------------------------------------- +struct GameWebCallback_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 64 }; + char m_szURL[256]; +}; + +//----------------------------------------------------------------------------- +// Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL +//----------------------------------------------------------------------------- +struct StoreAuthURLResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 65 }; + char m_szURL[512]; +}; + + +//----------------------------------------------------------------------------- +// Purpose: sent in response to ISteamUser::GetMarketEligibility +//----------------------------------------------------------------------------- +struct MarketEligibilityResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 66 }; + bool m_bAllowed; + EMarketNotAllowedReasonFlags m_eNotAllowedReason; + RTime32 m_rtAllowedAtTime; + + int m_cdaySteamGuardRequiredDays; // The number of days any user is required to have had Steam Guard before they can use the market + int m_cdayNewDeviceCooldown; // The number of days after initial device authorization a user must wait before using the market on that device +}; + + +//----------------------------------------------------------------------------- +// Purpose: sent for games with enabled anti indulgence / duration control, for +// enabled users. Lets the game know whether the user can keep playing or +// whether the game should exit, and returns info about remaining gameplay time. +// +// This callback is fired asynchronously in response to timers triggering. +// It is also fired in response to calls to GetDurationControl(). +//----------------------------------------------------------------------------- +struct DurationControl_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 67 }; + + EResult m_eResult; // result of call (always k_EResultOK for asynchronous timer-based notifications) + AppId_t m_appid; // appid generating playtime + + bool m_bApplicable; // is duration control applicable to user + game combination + int32 m_csecsLast5h; // playtime since most recent 5 hour gap in playtime, only counting up to regulatory limit of playtime, in seconds + + EDurationControlProgress m_progress; // recommended progress (either everything is fine, or please exit game) + EDurationControlNotification m_notification; // notification to show, if any (always k_EDurationControlNotification_None for API calls) + + int32 m_csecsToday; // playtime on current calendar day + int32 m_csecsRemaining; // playtime remaining until the user hits a regulatory limit +}; + + +//----------------------------------------------------------------------------- +// callback for GetTicketForWebApi +//----------------------------------------------------------------------------- +struct GetTicketForWebApiResponse_t +{ + enum { k_iCallback = k_iSteamUserCallbacks + 68 }; + HAuthTicket m_hAuthTicket; + EResult m_eResult; + int m_cubTicket; + static const int k_nCubTicketMaxLength = 2560; + uint8 m_rgubTicket[k_nCubTicketMaxLength]; +}; + + +#pragma pack( pop ) + +#endif // ISTEAMUSER_H diff --git a/lsteamclient/steamworks_sdk_160/isteamuserstats.h b/lsteamclient/steamworks_sdk_160/isteamuserstats.h new file mode 100644 index 0000000000..8bb0c90f19 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamuserstats.h @@ -0,0 +1,487 @@ +//====== Copyright � 1996-2009, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to stats, achievements, and leaderboards +// +//============================================================================= + +#ifndef ISTEAMUSERSTATS_H +#define ISTEAMUSERSTATS_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" +#include "isteamremotestorage.h" + +// size limit on stat or achievement name (UTF-8 encoded) +enum { k_cchStatNameMax = 128 }; + +// maximum number of bytes for a leaderboard name (UTF-8 encoded) +enum { k_cchLeaderboardNameMax = 128 }; + +// maximum number of details int32's storable for a single leaderboard entry +enum { k_cLeaderboardDetailsMax = 64 }; + +// handle to a single leaderboard +typedef uint64 SteamLeaderboard_t; + +// handle to a set of downloaded entries in a leaderboard +typedef uint64 SteamLeaderboardEntries_t; + +// type of data request, when downloading leaderboard entries +enum ELeaderboardDataRequest +{ + k_ELeaderboardDataRequestGlobal = 0, + k_ELeaderboardDataRequestGlobalAroundUser = 1, + k_ELeaderboardDataRequestFriends = 2, + k_ELeaderboardDataRequestUsers = 3 +}; + +// the sort order of a leaderboard +enum ELeaderboardSortMethod +{ + k_ELeaderboardSortMethodNone = 0, + k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number + k_ELeaderboardSortMethodDescending = 2, // top-score is highest number +}; + +// the display type (used by the Steam Community web site) for a leaderboard +enum ELeaderboardDisplayType +{ + k_ELeaderboardDisplayTypeNone = 0, + k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score + k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds + k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds +}; + +enum ELeaderboardUploadScoreMethod +{ + k_ELeaderboardUploadScoreMethodNone = 0, + k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score + k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified +}; + +// a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry() +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +struct LeaderboardEntry_t +{ + CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info + int32 m_nGlobalRank; // [1..N], where N is the number of users with an entry in the leaderboard + int32 m_nScore; // score as set in the leaderboard + int32 m_cDetails; // number of int32 details available for this entry + UGCHandle_t m_hUGC; // handle for UGC attached to the entry +}; + +#pragma pack( pop ) + + +//----------------------------------------------------------------------------- +// Purpose: Functions for accessing stats, achievements, and leaderboard information +//----------------------------------------------------------------------------- +class ISteamUserStats +{ +public: + // Ask the server to send down this user's data and achievements for this game + STEAM_CALL_BACK( UserStatsReceived_t ) + virtual bool RequestCurrentStats() = 0; + + // Data accessors + STEAM_FLAT_NAME( GetStatInt32 ) + virtual bool GetStat( const char *pchName, int32 *pData ) = 0; + + STEAM_FLAT_NAME( GetStatFloat ) + virtual bool GetStat( const char *pchName, float *pData ) = 0; + + // Set / update data + STEAM_FLAT_NAME( SetStatInt32 ) + virtual bool SetStat( const char *pchName, int32 nData ) = 0; + + STEAM_FLAT_NAME( SetStatFloat ) + virtual bool SetStat( const char *pchName, float fData ) = 0; + + virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0; + + // Achievement flag accessors + virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0; + virtual bool SetAchievement( const char *pchName ) = 0; + virtual bool ClearAchievement( const char *pchName ) = 0; + + // Get the achievement status, and the time it was unlocked if unlocked. + // If the return value is true, but the unlock time is zero, that means it was unlocked before Steam + // began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970. + virtual bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0; + + // Store the current data on the server, will get a callback when set + // And one callback for every new achievement + // + // If the callback has a result of k_EResultInvalidParam, one or more stats + // uploaded has been rejected, either because they broke constraints + // or were out of date. In this case the server sends back updated values. + // The stats should be re-iterated to keep in sync. + virtual bool StoreStats() = 0; + + // Achievement / GroupAchievement metadata + + // Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set. + // A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback + // which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the + // specified achievement. + virtual int GetAchievementIcon( const char *pchName ) = 0; + + // Get general attributes for an achievement. Accepts the following keys: + // - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8) + // - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden) + virtual const char *GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) = 0; + + // Achievement progress - triggers an AchievementProgress callback, that is all. + // Calling this w/ N out of N progress will NOT set the achievement, the game must still do that. + virtual bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress ) = 0; + + // Used for iterating achievements. In general games should not need these functions because they should have a + // list of existing achievements compiled into them + virtual uint32 GetNumAchievements() = 0; + // Get achievement name iAchievement in [0,GetNumAchievements) + virtual const char *GetAchievementName( uint32 iAchievement ) = 0; + + // Friends stats & achievements + + // downloads stats for the user + // returns a UserStatsReceived_t received when completed + // if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail + // these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data + STEAM_CALL_RESULT( UserStatsReceived_t ) + virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0; + + // requests stat information for a user, usable after a successful call to RequestUserStats() + STEAM_FLAT_NAME( GetUserStatInt32 ) + virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0; + + STEAM_FLAT_NAME( GetUserStatFloat ) + virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0; + + virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0; + // See notes for GetAchievementAndUnlockTime above + virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0; + + // Reset stats + virtual bool ResetAllStats( bool bAchievementsToo ) = 0; + + // Leaderboard functions + + // asks the Steam back-end for a leaderboard by name, and will create it if it's not yet + // This call is asynchronous, with the result returned in LeaderboardFindResult_t + STEAM_CALL_RESULT(LeaderboardFindResult_t) + virtual SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) = 0; + + // as above, but won't create the leaderboard if it's not found + // This call is asynchronous, with the result returned in LeaderboardFindResult_t + STEAM_CALL_RESULT( LeaderboardFindResult_t ) + virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0; + + // returns the name of a leaderboard + virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0; + + // returns the total number of entries in a leaderboard, as of the last request + virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0; + + // returns the sort method of the leaderboard + virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0; + + // returns the display type of the leaderboard + virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0; + + // Asks the Steam back-end for a set of rows in the leaderboard. + // This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t + // LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below) + // You can ask for more entries than exist, and it will return as many as do exist. + // k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries] + // k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate + // e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after + // k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user + STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) + virtual SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) = 0; + // as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers + // if a user doesn't have a leaderboard entry, they won't be included in the result + // a max of 100 users can be downloaded at a time, with only one outstanding call at a time + STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) + virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, + STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0; + + // Returns data about a single leaderboard entry + // use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries + // e.g. + // void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded ) + // { + // for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ ) + // { + // LeaderboardEntry_t leaderboardEntry; + // int32 details[3]; // we know this is how many we've stored previously + // GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 ); + // assert( leaderboardEntry.m_cDetails == 3 ); + // ... + // } + // once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid + virtual bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) = 0; + + // Uploads a user score to the Steam back-end. + // This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t + // Details are extra game-defined information regarding how the user got that score + // pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list + STEAM_CALL_RESULT( LeaderboardScoreUploaded_t ) + virtual SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) = 0; + + // Attaches a piece of user generated content the user's entry on a leaderboard. + // hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare(). + // This call is asynchronous, with the result returned in LeaderboardUGCSet_t. + STEAM_CALL_RESULT( LeaderboardUGCSet_t ) + virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0; + + // Retrieves the number of players currently playing your game (online + offline) + // This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t + STEAM_CALL_RESULT( NumberOfCurrentPlayers_t ) + virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0; + + // Requests that Steam fetch data on the percentage of players who have received each achievement + // for the game globally. + // This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t. + STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t ) + virtual SteamAPICall_t RequestGlobalAchievementPercentages() = 0; + + // Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch + // the next most achieved afterwards. Will return -1 if there is no data on achievement + // percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback). + virtual int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; + + // Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another + // GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last + // achievement has been iterated. + virtual int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; + + // Returns the percentage of users who have achieved the specified achievement. + virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0; + + // Requests global stats data, which is available for stats marked as "aggregated". + // This call is asynchronous, with the results returned in GlobalStatsReceived_t. + // nHistoryDays specifies how many days of day-by-day history to retrieve in addition + // to the overall totals. The limit is 60. + STEAM_CALL_RESULT( GlobalStatsReceived_t ) + virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0; + + // Gets the lifetime totals for an aggregated stat + STEAM_FLAT_NAME( GetGlobalStatInt64 ) + virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0; + + STEAM_FLAT_NAME( GetGlobalStatDouble ) + virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0; + + // Gets history for an aggregated stat. pData will be filled with daily values, starting with today. + // So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago, + // etc. cubData is the size in bytes of the pubData buffer. Returns the number of + // elements actually set. + + STEAM_FLAT_NAME( GetGlobalStatHistoryInt64 ) + virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0; + + STEAM_FLAT_NAME( GetGlobalStatHistoryDouble ) + virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) double *pData, uint32 cubData ) = 0; + + // For achievements that have related Progress stats, use this to query what the bounds of that progress are. + // You may want this info to selectively call IndicateAchievementProgress when appropriate milestones of progress + // have been made, to show a progress notification to the user. + STEAM_FLAT_NAME( GetAchievementProgressLimitsInt32 ) + virtual bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) = 0; + + STEAM_FLAT_NAME( GetAchievementProgressLimitsFloat ) + virtual bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) = 0; + +}; + +#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION012" + +// Global interface accessor +inline ISteamUserStats *SteamUserStats(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUserStats *, SteamUserStats, STEAMUSERSTATS_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: called when the latests stats and achievements have been received +// from the server +//----------------------------------------------------------------------------- +struct UserStatsReceived_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 }; + uint64 m_nGameID; // Game these stats are for + EResult m_eResult; // Success / error fetching the stats + CSteamID m_steamIDUser; // The user for whom the stats are retrieved for +}; + + +//----------------------------------------------------------------------------- +// Purpose: result of a request to store the user stats for a game +//----------------------------------------------------------------------------- +struct UserStatsStored_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 }; + uint64 m_nGameID; // Game these stats are for + EResult m_eResult; // success / error +}; + + +//----------------------------------------------------------------------------- +// Purpose: result of a request to store the achievements for a game, or an +// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress +// are zero, that means the achievement has been fully unlocked. +//----------------------------------------------------------------------------- +struct UserAchievementStored_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 }; + + uint64 m_nGameID; // Game this is for + bool m_bGroupAchievement; // if this is a "group" achievement + char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement + uint32 m_nCurProgress; // current progress towards the achievement + uint32 m_nMaxProgress; // "out of" this many +}; + + +//----------------------------------------------------------------------------- +// Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard() +// use CCallResult<> to map this async result to a member function +//----------------------------------------------------------------------------- +struct LeaderboardFindResult_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 4 }; + SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found + uint8 m_bLeaderboardFound; // 0 if no leaderboard found +}; + + +//----------------------------------------------------------------------------- +// Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries() +// use CCallResult<> to map this async result to a member function +//----------------------------------------------------------------------------- +struct LeaderboardScoresDownloaded_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 5 }; + SteamLeaderboard_t m_hSteamLeaderboard; + SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries() + int m_cEntryCount; // the number of entries downloaded +}; + + +//----------------------------------------------------------------------------- +// Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore() +// use CCallResult<> to map this async result to a member function +//----------------------------------------------------------------------------- +struct LeaderboardScoreUploaded_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 6 }; + uint8 m_bSuccess; // 1 if the call was successful + SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was + int32 m_nScore; // the score that was attempted to set + uint8 m_bScoreChanged; // true if the score in the leaderboard change, false if the existing score was better + int m_nGlobalRankNew; // the new global rank of the user in this leaderboard + int m_nGlobalRankPrevious; // the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard +}; + +struct NumberOfCurrentPlayers_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 7 }; + uint8 m_bSuccess; // 1 if the call was successful + int32 m_cPlayers; // Number of players currently playing +}; + + + +//----------------------------------------------------------------------------- +// Purpose: Callback indicating that a user's stats have been unloaded. +// Call RequestUserStats again to access stats for this user +//----------------------------------------------------------------------------- +struct UserStatsUnloaded_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 }; + CSteamID m_steamIDUser; // User whose stats have been unloaded +}; + + + +//----------------------------------------------------------------------------- +// Purpose: Callback indicating that an achievement icon has been fetched +//----------------------------------------------------------------------------- +struct UserAchievementIconFetched_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 9 }; + + CGameID m_nGameID; // Game this is for + char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement + bool m_bAchieved; // Is the icon for the achieved or not achieved version? + int m_nIconHandle; // Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement +}; + + +//----------------------------------------------------------------------------- +// Purpose: Callback indicating that global achievement percentages are fetched +//----------------------------------------------------------------------------- +struct GlobalAchievementPercentagesReady_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 10 }; + + uint64 m_nGameID; // Game this is for + EResult m_eResult; // Result of the operation +}; + + +//----------------------------------------------------------------------------- +// Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC() +//----------------------------------------------------------------------------- +struct LeaderboardUGCSet_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 11 }; + EResult m_eResult; // The result of the operation + SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was +}; + + +//----------------------------------------------------------------------------- +// Purpose: callback indicating that PS3 trophies have been installed +//----------------------------------------------------------------------------- +struct PS3TrophiesInstalled_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 }; + uint64 m_nGameID; // Game these stats are for + EResult m_eResult; // The result of the operation + uint64 m_ulRequiredDiskSpace; // If m_eResult is k_EResultDiskFull, will contain the amount of space needed to install trophies + +}; + + +//----------------------------------------------------------------------------- +// Purpose: callback indicating global stats have been received. +// Returned as a result of RequestGlobalStats() +//----------------------------------------------------------------------------- +struct GlobalStatsReceived_t +{ + enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 }; + uint64 m_nGameID; // Game global stats were requested for + EResult m_eResult; // The result of the request +}; + +#pragma pack( pop ) + + +#endif // ISTEAMUSER_H diff --git a/lsteamclient/steamworks_sdk_160/isteamutils.h b/lsteamclient/steamworks_sdk_160/isteamutils.h new file mode 100644 index 0000000000..be5acb282d --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamutils.h @@ -0,0 +1,343 @@ +//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to utility functions in Steam +// +//============================================================================= + +#ifndef ISTEAMUTILS_H +#define ISTEAMUTILS_H + +#include "steam_api_common.h" + + +// Steam API call failure results +enum ESteamAPICallFailure +{ + k_ESteamAPICallFailureNone = -1, // no failure + k_ESteamAPICallFailureSteamGone = 0, // the local Steam process has gone away + k_ESteamAPICallFailureNetworkFailure = 1, // the network connection to Steam has been broken, or was already broken + // SteamServersDisconnected_t callback will be sent around the same time + // SteamServersConnected_t will be sent when the client is able to talk to the Steam servers again + k_ESteamAPICallFailureInvalidHandle = 2, // the SteamAPICall_t handle passed in no longer exists + k_ESteamAPICallFailureMismatchedCallback = 3,// GetAPICallResult() was called with the wrong callback type for this API call +}; + + +// Input modes for the Big Picture gamepad text entry +enum EGamepadTextInputMode +{ + k_EGamepadTextInputModeNormal = 0, + k_EGamepadTextInputModePassword = 1 +}; + + +// Controls number of allowed lines for the Big Picture gamepad text entry +enum EGamepadTextInputLineMode +{ + k_EGamepadTextInputLineModeSingleLine = 0, + k_EGamepadTextInputLineModeMultipleLines = 1 +}; + +enum EFloatingGamepadTextInputMode +{ + k_EFloatingGamepadTextInputModeModeSingleLine = 0, // Enter dismisses the keyboard + k_EFloatingGamepadTextInputModeModeMultipleLines = 1, // User needs to explictly close the keyboard + k_EFloatingGamepadTextInputModeModeEmail = 2, // Keyboard layout is email, enter dismisses the keyboard + k_EFloatingGamepadTextInputModeModeNumeric = 3, // Keyboard layout is numeric, enter dismisses the keyboard + +}; + +// The context where text filtering is being done +enum ETextFilteringContext +{ + k_ETextFilteringContextUnknown = 0, // Unknown context + k_ETextFilteringContextGameContent = 1, // Game content, only legally required filtering is performed + k_ETextFilteringContextChat = 2, // Chat from another player + k_ETextFilteringContextName = 3, // Character or item name +}; + + +//----------------------------------------------------------------------------- +// Purpose: interface to user independent utility functions +//----------------------------------------------------------------------------- +class ISteamUtils +{ +public: + // return the number of seconds since the user + virtual uint32 GetSecondsSinceAppActive() = 0; + virtual uint32 GetSecondsSinceComputerActive() = 0; + + // the universe this client is connecting to + virtual EUniverse GetConnectedUniverse() = 0; + + // Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time) + virtual uint32 GetServerRealTime() = 0; + + // returns the 2 digit ISO 3166-1-alpha-2 format country code this client is running in (as looked up via an IP-to-location database) + // e.g "US" or "UK". + virtual const char *GetIPCountry() = 0; + + // returns true if the image exists, and valid sizes were filled out + virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0; + + // returns true if the image exists, and the buffer was successfully filled out + // results are returned in RGBA format + // the destination buffer size should be 4 * height * width * sizeof(char) + virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0; + + // Deprecated. Do not call this. + STEAM_PRIVATE_API( virtual bool GetCSERIPPort( uint32 *unIP, uint16 *usPort ) = 0; ) + + // return the amount of battery power left in the current system in % [0..100], 255 for being on AC power + virtual uint8 GetCurrentBatteryPower() = 0; + + // returns the appID of the current process + virtual uint32 GetAppID() = 0; + + // Sets the position where the overlay instance for the currently calling game should show notifications. + // This position is per-game and if this function is called from outside of a game context it will do nothing. + virtual void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition ) = 0; + + // API asynchronous call results + // can be used directly, but more commonly used via the callback dispatch API (see steam_api.h) + virtual bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed ) = 0; + virtual ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) = 0; + virtual bool GetAPICallResult( SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ) = 0; + + // Deprecated. Applications should use SteamAPI_RunCallbacks() instead. Game servers do not need to call this function. + STEAM_PRIVATE_API( virtual void RunFrame() = 0; ) + + // returns the number of IPC calls made since the last time this function was called + // Used for perf debugging so you can understand how many IPC calls your game makes per frame + // Every IPC call is at minimum a thread context switch if not a process one so you want to rate + // control how often you do them. + virtual uint32 GetIPCCallCount() = 0; + + // API warning handling + // 'int' is the severity; 0 for msg, 1 for warning + // 'const char *' is the text of the message + // callbacks will occur directly after the API function is called that generated the warning or message + virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0; + + // Returns true if the overlay is running & the user can access it. The overlay process could take a few seconds to + // start & hook the game process, so this function will initially return false while the overlay is loading. + virtual bool IsOverlayEnabled() = 0; + + // Normally this call is unneeded if your game has a constantly running frame loop that calls the + // D3D Present API, or OGL SwapBuffers API every frame. + // + // However, if you have a game that only refreshes the screen on an event driven basis then that can break + // the overlay, as it uses your Present/SwapBuffers calls to drive it's internal frame loop and it may also + // need to Present() to the screen any time an even needing a notification happens or when the overlay is + // brought up over the game by a user. You can use this API to ask the overlay if it currently need a present + // in that case, and then you can check for this periodically (roughly 33hz is desirable) and make sure you + // refresh the screen with Present or SwapBuffers to allow the overlay to do it's work. + virtual bool BOverlayNeedsPresent() = 0; + + // Asynchronous call to check if an executable file has been signed using the public key set on the signing tab + // of the partner site, for example to refuse to load modified executable files. + // The result is returned in CheckFileSignature_t. + // k_ECheckFileSignatureNoSignaturesFoundForThisApp - This app has not been configured on the signing tab of the partner site to enable this function. + // k_ECheckFileSignatureNoSignaturesFoundForThisFile - This file is not listed on the signing tab for the partner site. + // k_ECheckFileSignatureFileNotFound - The file does not exist on disk. + // k_ECheckFileSignatureInvalidSignature - The file exists, and the signing tab has been set for this file, but the file is either not signed or the signature does not match. + // k_ECheckFileSignatureValidSignature - The file is signed and the signature is valid. + STEAM_CALL_RESULT( CheckFileSignature_t ) + virtual SteamAPICall_t CheckFileSignature( const char *szFileName ) = 0; + + // Activates the full-screen text input dialog which takes a initial text string and returns the text the user has typed + virtual bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText ) = 0; + + // Returns previously entered text & length + virtual uint32 GetEnteredGamepadTextLength() = 0; + virtual bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText ) = 0; + + // returns the language the steam client is running in, you probably want ISteamApps::GetCurrentGameLanguage instead, this is for very special usage cases + virtual const char *GetSteamUILanguage() = 0; + + // returns true if Steam itself is running in VR mode + virtual bool IsSteamRunningInVR() = 0; + + // Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition. + virtual void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) = 0; + + // returns true if Steam & the Steam Overlay are running in Big Picture mode + // Games much be launched through the Steam client to enable the Big Picture overlay. During development, + // a game can be added as a non-steam game to the developers library to test this feature + virtual bool IsSteamInBigPictureMode() = 0; + + // ask SteamUI to create and render its OpenVR dashboard + virtual void StartVRDashboard() = 0; + + // Returns true if the HMD content will be streamed via Steam Remote Play + virtual bool IsVRHeadsetStreamingEnabled() = 0; + + // Set whether the HMD content will be streamed via Steam Remote Play + // If this is set to true, then the scene in the HMD headset will be streamed, and remote input will not be allowed. + // If this is set to false, then the application window will be streamed instead, and remote input will be allowed. + // The default is true unless "VRHeadsetStreaming" "0" is in the extended appinfo for a game. + // (this is useful for games that have asymmetric multiplayer gameplay) + virtual void SetVRHeadsetStreamingEnabled( bool bEnabled ) = 0; + + // Returns whether this steam client is a Steam China specific client, vs the global client. + virtual bool IsSteamChinaLauncher() = 0; + + // Initializes text filtering, loading dictionaries for the language the game is running in. + // unFilterOptions are reserved for future use and should be set to 0 + // Returns false if filtering is unavailable for the game's language, in which case FilterText() will act as a passthrough. + // + // Users can customize the text filter behavior in their Steam Account preferences: + // https://store.steampowered.com/account/preferences#CommunityContentPreferences + virtual bool InitFilterText( uint32 unFilterOptions = 0 ) = 0; + + // Filters the provided input message and places the filtered result into pchOutFilteredText, using legally required filtering and additional filtering based on the context and user settings + // eContext is the type of content in the input string + // sourceSteamID is the Steam ID that is the source of the input string (e.g. the player with the name, or who said the chat text) + // pchInputText is the input string that should be filtered, which can be ASCII or UTF-8 + // pchOutFilteredText is where the output will be placed, even if no filtering is performed + // nByteSizeOutFilteredText is the size (in bytes) of pchOutFilteredText, should be at least strlen(pchInputText)+1 + // Returns the number of characters (not bytes) filtered + virtual int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const char *pchInputMessage, char *pchOutFilteredText, uint32 nByteSizeOutFilteredText ) = 0; + + // Return what we believe your current ipv6 connectivity to "the internet" is on the specified protocol. + // This does NOT tell you if the Steam client is currently connected to Steam via ipv6. + virtual ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol ) = 0; + + // returns true if currently running on the Steam Deck device + virtual bool IsSteamRunningOnSteamDeck() = 0; + + // Opens a floating keyboard over the game content and sends OS keyboard keys directly to the game. + // The text field position is specified in pixels relative the origin of the game window and is used to position the floating keyboard in a way that doesn't cover the text field + virtual bool ShowFloatingGamepadTextInput( EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight ) = 0; + + // In game launchers that don't have controller support you can call this to have Steam Input translate the controller input into mouse/kb to navigate the launcher + virtual void SetGameLauncherMode( bool bLauncherMode ) = 0; + + // Dismisses the floating keyboard. + virtual bool DismissFloatingGamepadTextInput() = 0; + + // Dismisses the full-screen text input dialog. + virtual bool DismissGamepadTextInput() = 0; +}; + +#define STEAMUTILS_INTERFACE_VERSION "SteamUtils010" + +// Global interface accessor +inline ISteamUtils *SteamUtils(); +STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamUtils, SteamInternal_FindOrCreateUserInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "user", STEAMUTILS_INTERFACE_VERSION ); + +// Global accessor for the gameserver client +inline ISteamUtils *SteamGameServerUtils(); +STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamGameServerUtils, SteamInternal_FindOrCreateGameServerInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "gameserver", STEAMUTILS_INTERFACE_VERSION ); + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: The country of the user changed +//----------------------------------------------------------------------------- +struct IPCountry_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 1 }; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Fired when running on a handheld PC or laptop with less than 10 minutes of battery is left, fires then every minute +//----------------------------------------------------------------------------- +struct LowBatteryPower_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 2 }; + uint8 m_nMinutesBatteryLeft; +}; + + +//----------------------------------------------------------------------------- +// Purpose: called when a SteamAsyncCall_t has completed (or failed) +//----------------------------------------------------------------------------- +struct SteamAPICallCompleted_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 3 }; + SteamAPICall_t m_hAsyncCall; + int m_iCallback; + uint32 m_cubParam; +}; + + +//----------------------------------------------------------------------------- +// called when Steam wants to shutdown +//----------------------------------------------------------------------------- +struct SteamShutdown_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 4 }; +}; + +//----------------------------------------------------------------------------- +// results for CheckFileSignature +//----------------------------------------------------------------------------- +enum ECheckFileSignature +{ + k_ECheckFileSignatureInvalidSignature = 0, + k_ECheckFileSignatureValidSignature = 1, + k_ECheckFileSignatureFileNotFound = 2, + k_ECheckFileSignatureNoSignaturesFoundForThisApp = 3, + k_ECheckFileSignatureNoSignaturesFoundForThisFile = 4, +}; + +//----------------------------------------------------------------------------- +// callback for CheckFileSignature +//----------------------------------------------------------------------------- +struct CheckFileSignature_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 5 }; + ECheckFileSignature m_eCheckFileSignature; +}; + + +// k_iSteamUtilsCallbacks + 13 is taken + + +//----------------------------------------------------------------------------- +// Full Screen gamepad text input has been closed +//----------------------------------------------------------------------------- +struct GamepadTextInputDismissed_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 14 }; + bool m_bSubmitted; // true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input + uint32 m_unSubmittedText; + AppId_t m_unAppID; +}; + +// k_iSteamUtilsCallbacks + 15 through 35 are taken + +STEAM_CALLBACK_BEGIN( AppResumingFromSuspend_t, k_iSteamUtilsCallbacks + 36 ) +STEAM_CALLBACK_END(0) + +// k_iSteamUtilsCallbacks + 37 is taken + +//----------------------------------------------------------------------------- +// The floating on-screen keyboard has been closed +//----------------------------------------------------------------------------- +struct FloatingGamepadTextInputDismissed_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 38 }; +}; + +//----------------------------------------------------------------------------- +// The text filtering dictionary has changed +//----------------------------------------------------------------------------- +struct FilterTextDictionaryChanged_t +{ + enum { k_iCallback = k_iSteamUtilsCallbacks + 39 }; + int m_eLanguage; // One of ELanguage, or k_LegallyRequiredFiltering +}; + +#pragma pack( pop ) + +#endif // ISTEAMUTILS_H diff --git a/lsteamclient/steamworks_sdk_160/isteamvideo.h b/lsteamclient/steamworks_sdk_160/isteamvideo.h new file mode 100644 index 0000000000..cd7b197153 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/isteamvideo.h @@ -0,0 +1,67 @@ +//====== Copyright © 1996-2014 Valve Corporation, All rights reserved. ======= +// +// Purpose: interface to Steam Video +// +//============================================================================= + +#ifndef ISTEAMVIDEO_H +#define ISTEAMVIDEO_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api_common.h" + +// callbacks +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +//----------------------------------------------------------------------------- +// Purpose: Steam Video API +//----------------------------------------------------------------------------- +class ISteamVideo +{ +public: + + // Get a URL suitable for streaming the given Video app ID's video + virtual void GetVideoURL( AppId_t unVideoAppID ) = 0; + + // returns true if user is uploading a live broadcast + virtual bool IsBroadcasting( int *pnNumViewers ) = 0; + + // Get the OPF Details for 360 Video Playback + STEAM_CALL_BACK( GetOPFSettingsResult_t ) + virtual void GetOPFSettings( AppId_t unVideoAppID ) = 0; + virtual bool GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize ) = 0; + + +}; + +#define STEAMVIDEO_INTERFACE_VERSION "STEAMVIDEO_INTERFACE_V007" + +// Global interface accessor +inline ISteamVideo *SteamVideo(); +STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamVideo *, SteamVideo, STEAMVIDEO_INTERFACE_VERSION ); + +STEAM_CALLBACK_BEGIN( GetVideoURLResult_t, k_iSteamVideoCallbacks + 11 ) + STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult ) + STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID ) + STEAM_CALLBACK_MEMBER( 2, char, m_rgchURL[256] ) +STEAM_CALLBACK_END(3) + + +STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iSteamVideoCallbacks + 24 ) + STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult ) + STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID ) +STEAM_CALLBACK_END(2) + + +#pragma pack( pop ) + + +#endif // ISTEAMVIDEO_H diff --git a/lsteamclient/steamworks_sdk_160/matchmakingtypes.h b/lsteamclient/steamworks_sdk_160/matchmakingtypes.h new file mode 100644 index 0000000000..791802a063 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/matchmakingtypes.h @@ -0,0 +1,231 @@ +//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ +// +// Purpose: +// +// $NoKeywords: $ +//============================================================================= + +#ifndef MATCHMAKINGTYPES_H +#define MATCHMAKINGTYPES_H + +#include +#include + +// +// Max size (in bytes of UTF-8 data, not in characters) of server fields, including null terminator. +// WARNING: These cannot be changed easily, without breaking clients using old interfaces. +// +const int k_cbMaxGameServerGameDir = 32; +const int k_cbMaxGameServerMapName = 32; +const int k_cbMaxGameServerGameDescription = 64; +const int k_cbMaxGameServerName = 64; +const int k_cbMaxGameServerTags = 128; +const int k_cbMaxGameServerGameData = 2048; + +/// Store key/value pair used in matchmaking queries. +/// +/// Actually, the name Key/Value is a bit misleading. The "key" is better +/// understood as "filter operation code" and the "value" is the operand to this +/// filter operation. The meaning of the operand depends upon the filter. +struct MatchMakingKeyValuePair_t +{ + MatchMakingKeyValuePair_t() { m_szKey[0] = m_szValue[0] = 0; } + MatchMakingKeyValuePair_t( const char *pchKey, const char *pchValue ) + { + strncpy( m_szKey, pchKey, sizeof(m_szKey) ); // this is a public header, use basic c library string funcs only! + m_szKey[ sizeof( m_szKey ) - 1 ] = '\0'; + strncpy( m_szValue, pchValue, sizeof(m_szValue) ); + m_szValue[ sizeof( m_szValue ) - 1 ] = '\0'; + } + char m_szKey[ 256 ]; + char m_szValue[ 256 ]; +}; + + +enum EMatchMakingServerResponse +{ + eServerResponded = 0, + eServerFailedToRespond, + eNoServersListedOnMasterServer // for the Internet query type, returned in response callback if no servers of this type match +}; + +// servernetadr_t is all the addressing info the serverbrowser needs to know about a game server, +// namely: its IP, its connection port, and its query port. +class servernetadr_t +{ +public: + + servernetadr_t() : m_usConnectionPort( 0 ), m_usQueryPort( 0 ), m_unIP( 0 ) {} + + void Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort ); + + // Access the query port. + uint16 GetQueryPort() const; + void SetQueryPort( uint16 usPort ); + + // Access the connection port. + uint16 GetConnectionPort() const; + void SetConnectionPort( uint16 usPort ); + + // Access the IP + uint32 GetIP() const; + void SetIP( uint32 unIP ); + + // This gets the 'a.b.c.d:port' string with the connection port (instead of the query port). + const char *GetConnectionAddressString() const; + const char *GetQueryAddressString() const; + + // Comparison operators and functions. + bool operator<(const servernetadr_t &netadr) const; + void operator=( const servernetadr_t &that ) + { + m_usConnectionPort = that.m_usConnectionPort; + m_usQueryPort = that.m_usQueryPort; + m_unIP = that.m_unIP; + } + + +private: + const char *ToString( uint32 unIP, uint16 usPort ) const; + uint16 m_usConnectionPort; // (in HOST byte order) + uint16 m_usQueryPort; + uint32 m_unIP; +}; + + +inline void servernetadr_t::Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort ) +{ + m_unIP = ip; + m_usQueryPort = usQueryPort; + m_usConnectionPort = usConnectionPort; +} + +inline uint16 servernetadr_t::GetQueryPort() const +{ + return m_usQueryPort; +} + +inline void servernetadr_t::SetQueryPort( uint16 usPort ) +{ + m_usQueryPort = usPort; +} + +inline uint16 servernetadr_t::GetConnectionPort() const +{ + return m_usConnectionPort; +} + +inline void servernetadr_t::SetConnectionPort( uint16 usPort ) +{ + m_usConnectionPort = usPort; +} + +inline uint32 servernetadr_t::GetIP() const +{ + return m_unIP; +} + +inline void servernetadr_t::SetIP( uint32 unIP ) +{ + m_unIP = unIP; +} + +inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const +{ + static char s[4][64]; + static int nBuf = 0; + unsigned char *ipByte = (unsigned char *)&unIP; +#ifdef VALVE_BIG_ENDIAN + snprintf(s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[0]), (int)(ipByte[1]), (int)(ipByte[2]), (int)(ipByte[3]), usPort ); +#else + snprintf(s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[3]), (int)(ipByte[2]), (int)(ipByte[1]), (int)(ipByte[0]), usPort ); +#endif + const char *pchRet = s[nBuf]; + ++nBuf; + nBuf %= ( (sizeof(s)/sizeof(s[0])) ); + return pchRet; +} + +inline const char* servernetadr_t::GetConnectionAddressString() const +{ + return ToString( m_unIP, m_usConnectionPort ); +} + +inline const char* servernetadr_t::GetQueryAddressString() const +{ + return ToString( m_unIP, m_usQueryPort ); +} + +inline bool servernetadr_t::operator<(const servernetadr_t &netadr) const +{ + return ( m_unIP < netadr.m_unIP ) || ( m_unIP == netadr.m_unIP && m_usQueryPort < netadr.m_usQueryPort ); +} + +//----------------------------------------------------------------------------- +// Purpose: Data describing a single server +//----------------------------------------------------------------------------- +class gameserveritem_t +{ +public: + gameserveritem_t(); + + const char* GetName() const; + void SetName( const char *pName ); + +public: + servernetadr_t m_NetAdr; ///< IP/Query Port/Connection Port for this server + int m_nPing; ///< current ping time in milliseconds + bool m_bHadSuccessfulResponse; ///< server has responded successfully in the past + bool m_bDoNotRefresh; ///< server is marked as not responding and should no longer be refreshed + char m_szGameDir[k_cbMaxGameServerGameDir]; ///< current game directory + char m_szMap[k_cbMaxGameServerMapName]; ///< current map + char m_szGameDescription[k_cbMaxGameServerGameDescription]; ///< game description + uint32 m_nAppID; ///< Steam App ID of this server + int m_nPlayers; ///< total number of players currently on the server. INCLUDES BOTS!! + int m_nMaxPlayers; ///< Maximum players that can join this server + int m_nBotPlayers; ///< Number of bots (i.e simulated players) on this server + bool m_bPassword; ///< true if this server needs a password to join + bool m_bSecure; ///< Is this server protected by VAC + uint32 m_ulTimeLastPlayed; ///< time (in unix time) when this server was last played on (for favorite/history servers) + int m_nServerVersion; ///< server version as reported to Steam + +private: + + /// Game server name + char m_szServerName[k_cbMaxGameServerName]; + + // For data added after SteamMatchMaking001 add it here +public: + /// the tags this server exposes + char m_szGameTags[k_cbMaxGameServerTags]; + + /// steamID of the game server - invalid if it's doesn't have one (old server, or not connected to Steam) + CSteamID m_steamID; +}; + + +inline gameserveritem_t::gameserveritem_t() +{ + m_szGameDir[0] = m_szMap[0] = m_szGameDescription[0] = m_szServerName[0] = 0; + m_bHadSuccessfulResponse = m_bDoNotRefresh = m_bPassword = m_bSecure = false; + m_nPing = m_nAppID = m_nPlayers = m_nMaxPlayers = m_nBotPlayers = m_ulTimeLastPlayed = m_nServerVersion = 0; + m_szGameTags[0] = 0; +} + +inline const char* gameserveritem_t::GetName() const +{ + // Use the IP address as the name if nothing is set yet. + if ( m_szServerName[0] == 0 ) + return m_NetAdr.GetConnectionAddressString(); + else + return m_szServerName; +} + +inline void gameserveritem_t::SetName( const char *pName ) +{ + strncpy( m_szServerName, pName, sizeof( m_szServerName ) ); + m_szServerName[ sizeof( m_szServerName ) - 1 ] = '\0'; +} + + +#endif // MATCHMAKINGTYPES_H diff --git a/lsteamclient/steamworks_sdk_160/steam_api.h b/lsteamclient/steamworks_sdk_160/steam_api.h new file mode 100644 index 0000000000..71d3a8b796 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steam_api.h @@ -0,0 +1,266 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// This header includes *all* of the interfaces and callback structures +// in the Steamworks SDK, and some high level functions to control the SDK +// (init, shutdown, etc) that you probably only need in one or two files. +// +// To save your compile times, we recommend that you not include this file +// in header files. Instead, include the specific headers for the interfaces +// and callback structures you need. The one file you might consider including +// in your precompiled header (e.g. stdafx.h) is steam_api_common.h +// +//============================================================================= + +#ifndef STEAM_API_H +#define STEAM_API_H +#ifdef _WIN32 +#pragma once +#endif + +// Basic stuff +#include "steam_api_common.h" + +// All of the interfaces +#include "isteamclient.h" +#include "isteamuser.h" +#include "isteamfriends.h" +#include "isteamutils.h" +#include "isteammatchmaking.h" +#include "isteamuserstats.h" +#include "isteamapps.h" +#include "isteamnetworking.h" +#include "isteamremotestorage.h" +#include "isteamscreenshots.h" +#include "isteammusic.h" +#include "isteammusicremote.h" +#include "isteamhttp.h" +#include "isteamcontroller.h" +#include "isteamugc.h" +#include "isteamhtmlsurface.h" +#include "isteaminventory.h" +#include "isteamtimeline.h" +#include "isteamvideo.h" +#include "isteamparentalsettings.h" +#include "isteaminput.h" +#include "isteamremoteplay.h" +#include "isteamnetworkingmessages.h" +#include "isteamnetworkingsockets.h" +#include "isteamnetworkingutils.h" + + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// Steam API setup & shutdown +// +// These functions manage loading, initializing and shutdown of the steamclient.dll +// +//----------------------------------------------------------------------------------------------------------------------------------------------------------// + +enum ESteamAPIInitResult +{ + k_ESteamAPIInitResult_OK = 0, + k_ESteamAPIInitResult_FailedGeneric = 1, // Some other failure + k_ESteamAPIInitResult_NoSteamClient = 2, // We cannot connect to Steam, steam probably isn't running + k_ESteamAPIInitResult_VersionMismatch = 3, // Steam client appears to be out of date +}; + +// Initializing the Steamworks SDK +// ----------------------------- +// +// There are three different methods you can use to initialize the Steamworks SDK, depending on +// your project's environment. You should only use one method in your project. +// +// If you are able to include this C++ header in your project, we recommend using the following +// initialization methods. They will ensure that all ISteam* interfaces defined in other +// C++ header files have versions that are supported by the user's Steam Client: +// - SteamAPI_InitEx() for new projects so you can show a detailed error message to the user +// - SteamAPI_Init() for existing projects that only display a generic error message +// +// If you are unable to include this C++ header in your project and are dynamically loading +// Steamworks SDK methods from dll/so, you can use the following method: +// - SteamAPI_InitFlat() + + +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// On success k_ESteamAPIInitResult_OK is returned. Otherwise, returns a value that can be used +// to create a localized error message for the user. If pOutErrMsg is non-NULL, +// it will receive an example error message, in English, that explains the reason for the failure. +// +// Example usage: +// +// SteamErrMsg errMsg; +// if ( SteamAPI_Init(&errMsg) != k_ESteamAPIInitResult_OK ) +// FatalError( "Failed to init Steam. %s", errMsg ); +inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg ); + +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// Returns true on success +inline bool SteamAPI_Init() +{ + return SteamAPI_InitEx( NULL ) == k_ESteamAPIInitResult_OK; +} + +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// Same usage as SteamAPI_InitEx(), however does not verify ISteam* interfaces are +// supported by the user's client and is exported from the dll +S_API ESteamAPIInitResult S_CALLTYPE SteamAPI_InitFlat( SteamErrMsg *pOutErrMsg ); + +// SteamAPI_Shutdown should be called during process shutdown if possible. +S_API void S_CALLTYPE SteamAPI_Shutdown(); + +// SteamAPI_RestartAppIfNecessary ensures that your executable was launched through Steam. +// +// Returns true if the current process should terminate. Steam is now re-launching your application. +// +// Returns false if no action needs to be taken. This means that your executable was started through +// the Steam client, or a steam_appid.txt file is present in your game's directory (for development). +// Your current process should continue if false is returned. +// +// NOTE: If you use the Steam DRM wrapper on your primary executable file, this check is unnecessary +// since the DRM wrapper will ensure that your application was launched properly through Steam. +S_API bool S_CALLTYPE SteamAPI_RestartAppIfNecessary( uint32 unOwnAppID ); + +// Many Steam API functions allocate a small amount of thread-local memory for parameter storage. +// SteamAPI_ReleaseCurrentThreadMemory() will free API memory associated with the calling thread. +// This function is also called automatically by SteamAPI_RunCallbacks(), so a single-threaded +// program never needs to explicitly call this function. +S_API void S_CALLTYPE SteamAPI_ReleaseCurrentThreadMemory(); + + +// crash dump recording functions +S_API void S_CALLTYPE SteamAPI_WriteMiniDump( uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID ); +S_API void S_CALLTYPE SteamAPI_SetMiniDumpComment( const char *pchMsg ); + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// steamclient.dll private wrapper functions +// +// The following functions are part of abstracting API access to the steamclient.dll, but should only be used in very specific cases +//----------------------------------------------------------------------------------------------------------------------------------------------------------// + +// SteamAPI_IsSteamRunning() returns true if Steam is currently running +S_API bool S_CALLTYPE SteamAPI_IsSteamRunning(); + +// returns the filename path of the current running Steam process, used if you need to load an explicit steam dll by name. +// DEPRECATED - implementation is Windows only, and the path returned is a UTF-8 string which must be converted to UTF-16 for use with Win32 APIs +S_API const char *SteamAPI_GetSteamInstallPath(); + +// sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {} around calls to issuing callbacks +// This is ignored if you are using the manual callback dispatch method +S_API void SteamAPI_SetTryCatchCallbacks( bool bTryCatchCallbacks ); + +#if defined( VERSION_SAFE_STEAM_API_INTERFACES ) +// exists only for backwards compat with code written against older SDKs +S_API bool S_CALLTYPE SteamAPI_InitSafe(); +#endif + +#if defined(USE_BREAKPAD_HANDLER) || defined(STEAM_API_EXPORTS) +// this should be called before the game initialized the steam APIs +// pchDate should be of the format "Mmm dd yyyy" (such as from the __ DATE __ macro ) +// pchTime should be of the format "hh:mm:ss" (such as from the __ TIME __ macro ) +// bFullMemoryDumps (Win32 only) -- writes out a uuid-full.dmp in the client/dumps folder +// pvContext-- can be NULL, will be the void * context passed into m_pfnPreMinidumpCallback +// PFNPreMinidumpCallback m_pfnPreMinidumpCallback -- optional callback which occurs just before a .dmp file is written during a crash. Applications can hook this to allow adding additional information into the .dmp comment stream. +S_API void S_CALLTYPE SteamAPI_UseBreakpadCrashHandler( char const *pchVersion, char const *pchDate, char const *pchTime, bool bFullMemoryDumps, void *pvContext, PFNPreMinidumpCallback m_pfnPreMinidumpCallback ); +S_API void S_CALLTYPE SteamAPI_SetBreakpadAppID( uint32 unAppID ); +#endif + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// +// Manual callback loop +// +// An alternative method for dispatching callbacks. Similar to a windows message loop. +// +// If you use the manual callback dispatch, you must NOT use: +// +// - SteamAPI_RunCallbacks or SteamGameServer_RunCallbacks +// - STEAM_CALLBACK, CCallResult, CCallback, or CCallbackManual +// +// Here is the basic template for replacing SteamAPI_RunCallbacks() with manual dispatch +/* + + HSteamPipe hSteamPipe = SteamAPI_GetHSteamPipe(); // See also SteamGameServer_GetHSteamPipe() + SteamAPI_ManualDispatch_RunFrame( hSteamPipe ) + CallbackMsg_t callback; + while ( SteamAPI_ManualDispatch_GetNextCallback( hSteamPipe, &callback ) ) + { + // Check for dispatching API call results + if ( callback.m_iCallback == SteamAPICallCompleted_t::k_iCallback ) + { + SteamAPICallCompleted_t *pCallCompleted = (SteamAPICallCompleted_t *)callback. + void *pTmpCallResult = malloc( pCallback->m_cubParam ); + bool bFailed; + if ( SteamAPI_ManualDispatch_GetAPICallResult( hSteamPipe, pCallCompleted->m_hAsyncCall, pTmpCallResult, pCallback->m_cubParam, pCallback->m_iCallback, &bFailed ) ) + { + // Dispatch the call result to the registered handler(s) for the + // call identified by pCallCompleted->m_hAsyncCall + } + free( pTmpCallResult ); + } + else + { + // Look at callback.m_iCallback to see what kind of callback it is, + // and dispatch to appropriate handler(s) + } + SteamAPI_ManualDispatch_FreeLastCallback( hSteamPipe ); + } + +*/ +//----------------------------------------------------------------------------------------------------------------------------------------------------------// + +/// Inform the API that you wish to use manual event dispatch. This must be called after SteamAPI_Init, but before +/// you use any of the other manual dispatch functions below. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_Init(); + +/// Perform certain periodic actions that need to be performed. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_RunFrame( HSteamPipe hSteamPipe ); + +/// Fetch the next pending callback on the given pipe, if any. If a callback is available, true is returned +/// and the structure is populated. In this case, you MUST call SteamAPI_ManualDispatch_FreeLastCallback +/// (after dispatching the callback) before calling SteamAPI_ManualDispatch_GetNextCallback again. +S_API bool S_CALLTYPE SteamAPI_ManualDispatch_GetNextCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg ); + +/// You must call this after dispatching the callback, if SteamAPI_ManualDispatch_GetNextCallback returns true. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_FreeLastCallback( HSteamPipe hSteamPipe ); + +/// Return the call result for the specified call on the specified pipe. You really should +/// only call this in a handler for SteamAPICallCompleted_t callback. +S_API bool S_CALLTYPE SteamAPI_ManualDispatch_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ); + +// Internal implementation of SteamAPI_InitEx. This is done in a way that checks +// all of the versions of interfaces from headers being compiled into this code. +S_API ESteamAPIInitResult S_CALLTYPE SteamInternal_SteamAPI_Init( const char *pszInternalCheckInterfaceVersions, SteamErrMsg *pOutErrMsg ); +inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg ) +{ + const char *pszInternalCheckInterfaceVersions = + STEAMUTILS_INTERFACE_VERSION "\0" + STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0" + STEAMAPPS_INTERFACE_VERSION "\0" + STEAMCONTROLLER_INTERFACE_VERSION "\0" + STEAMFRIENDS_INTERFACE_VERSION "\0" + STEAMGAMESEARCH_INTERFACE_VERSION "\0" + STEAMHTMLSURFACE_INTERFACE_VERSION "\0" + STEAMHTTP_INTERFACE_VERSION "\0" + STEAMINPUT_INTERFACE_VERSION "\0" + STEAMINVENTORY_INTERFACE_VERSION "\0" + STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "\0" + STEAMMATCHMAKING_INTERFACE_VERSION "\0" + STEAMMUSICREMOTE_INTERFACE_VERSION "\0" + STEAMMUSIC_INTERFACE_VERSION "\0" + STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0" + STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0" + STEAMNETWORKING_INTERFACE_VERSION "\0" + STEAMPARENTALSETTINGS_INTERFACE_VERSION "\0" + STEAMPARTIES_INTERFACE_VERSION "\0" + STEAMREMOTEPLAY_INTERFACE_VERSION "\0" + STEAMREMOTESTORAGE_INTERFACE_VERSION "\0" + STEAMSCREENSHOTS_INTERFACE_VERSION "\0" + STEAMUGC_INTERFACE_VERSION "\0" + STEAMUSERSTATS_INTERFACE_VERSION "\0" + STEAMUSER_INTERFACE_VERSION "\0" + STEAMVIDEO_INTERFACE_VERSION "\0" + + "\0"; + + return SteamInternal_SteamAPI_Init( pszInternalCheckInterfaceVersions, pOutErrMsg ); +} + +#endif // STEAM_API_H diff --git a/lsteamclient/steamworks_sdk_160/steam_api_common.h b/lsteamclient/steamworks_sdk_160/steam_api_common.h new file mode 100644 index 0000000000..cb8e6b7797 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steam_api_common.h @@ -0,0 +1,249 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Steamworks SDK minimal include +// +// Defines the minimal set of things we need to use any single interface +// or register for any callback. +// +//============================================================================= + +#ifndef STEAM_API_COMMON_H +#define STEAM_API_COMMON_H + +#include "steamtypes.h" +#include "steamclientpublic.h" + +// S_API defines the linkage and calling conventions for steam_api.dll exports +#if defined( _WIN32 ) && !defined( _X360 ) + #if defined( STEAM_API_EXPORTS ) + #define S_API extern "C" __declspec( dllexport ) + #elif defined( STEAM_API_NODLL ) + #define S_API extern "C" + #else + #define S_API extern "C" __declspec( dllimport ) + #endif // STEAM_API_EXPORTS +#elif defined( __GNUC__ ) + #if defined( STEAM_API_EXPORTS ) + #define S_API extern "C" __attribute__ ((visibility("default"))) + #else + #define S_API extern "C" + #endif // STEAM_API_EXPORTS +#else // !WIN32 + #if defined( STEAM_API_EXPORTS ) + #define S_API extern "C" + #else + #define S_API extern "C" + #endif // STEAM_API_EXPORTS +#endif + +#if defined( __cplusplus ) && ( __cplusplus >= 201103L ) + #define S_OVERRIDE override +#else + #define S_OVERRIDE +#endif + +#if ( defined(STEAM_API_EXPORTS) || defined(STEAM_API_NODLL) ) && !defined(API_GEN) +#define STEAM_PRIVATE_API( ... ) __VA_ARGS__ +#elif defined(STEAM_API_EXPORTS) && defined(API_GEN) +#define STEAM_PRIVATE_API( ... ) +#else +#define STEAM_PRIVATE_API( ... ) protected: __VA_ARGS__ public: +#endif + +// handle to a communication pipe to the Steam client +typedef int32 HSteamPipe; +// handle to single instance of a steam user +typedef int32 HSteamUser; + +// A fixed size buffer to receive an error message that is returned by some API +// calls. +const int k_cchMaxSteamErrMsg = 1024; +typedef char SteamErrMsg[ k_cchMaxSteamErrMsg ]; + +// #define away __cdecl on posix. +// This is really, really bad. We're sorry. But it's been this way for +// a long time now and it's scary to change it, as there may be others that +// depend on it. +#ifndef _WIN32 + #define __cdecl +#endif + +// function prototype +extern "C" typedef void ( S_CALLTYPE *SteamAPIWarningMessageHook_t )( int, const char * ); +extern "C" typedef uint32 ( S_CALLTYPE *SteamAPI_CheckCallbackRegistered_t )( int iCallbackNum ); +#if defined( __SNC__ ) + #pragma diag_suppress=1700 // warning 1700: class "%s" has virtual functions but non-virtual destructor +#endif + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// steam callback and call-result helpers +// +// The following macros and classes are used to register your application for +// callbacks and call-results, which are delivered in a predictable manner. +// +// STEAM_CALLBACK macros are meant for use inside of a C++ class definition. +// They map a Steam notification callback directly to a class member function +// which is automatically prototyped as "void func( callback_type *pParam )". +// +// CCallResult is used with specific Steam APIs that return "result handles". +// The handle can be passed to a CCallResult object's Set function, along with +// an object pointer and member-function pointer. The member function will +// be executed once the results of the Steam API call are available. +// +// CCallback and CCallbackManual classes can be used instead of STEAM_CALLBACK +// macros if you require finer control over registration and unregistration. +// +// Callbacks and call-results are queued automatically and are only +// delivered/executed when your application calls SteamAPI_RunCallbacks(). +// +// Note that there is an alternative, lower level callback dispatch mechanism. +// See SteamAPI_ManualDispatch_Init +//----------------------------------------------------------------------------------------------------------------------------------------------------------// + +// Dispatch all queued Steamworks callbacks. +// +// This is safe to call from multiple threads simultaneously, +// but if you choose to do this, callback code could be executed on any thread. +// One alternative is to call SteamAPI_RunCallbacks from the main thread only, +// and call SteamAPI_ReleaseCurrentThreadMemory regularly on other threads. +S_API void S_CALLTYPE SteamAPI_RunCallbacks(); + +// Declares a callback member function plus a helper member variable which +// registers the callback on object creation and unregisters on destruction. +// The optional fourth 'var' param exists only for backwards-compatibility +// and can be ignored. +#define STEAM_CALLBACK( thisclass, func, .../*callback_type, [deprecated] var*/ ) \ + _STEAM_CALLBACK_SELECT( ( __VA_ARGS__, 4, 3 ), ( /**/, thisclass, func, __VA_ARGS__ ) ) + +// Declares a callback function and a named CCallbackManual variable which +// has Register and Unregister functions instead of automatic registration. +#define STEAM_CALLBACK_MANUAL( thisclass, func, callback_type, var ) \ + CCallbackManual< thisclass, callback_type > var; void func( callback_type *pParam ) + +// Dispatch callbacks relevant to the gameserver client and interfaces. +// To register for these, you need to use STEAM_GAMESERVER_CALLBACK. +// (Or call SetGameserverFlag on your CCallbackBase object.) +S_API void S_CALLTYPE SteamGameServer_RunCallbacks(); + +// Same as STEAM_CALLBACK, but for callbacks on the gameserver interface. +// These will be dispatched during SteamGameServer_RunCallbacks +#define STEAM_GAMESERVER_CALLBACK( thisclass, func, /*callback_type, [deprecated] var*/... ) \ + _STEAM_CALLBACK_SELECT( ( __VA_ARGS__, GS, 3 ), ( this->SetGameserverFlag();, thisclass, func, __VA_ARGS__ ) ) +#define STEAM_GAMESERVER_CALLBACK_MANUAL( thisclass, func, callback_type, var ) \ + CCallbackManual< thisclass, callback_type, true > var; void func( callback_type *pParam ) + +//----------------------------------------------------------------------------- +// Purpose: base for callbacks and call results - internal implementation detail +//----------------------------------------------------------------------------- +class CCallbackBase +{ +public: + CCallbackBase() { m_nCallbackFlags = 0; m_iCallback = 0; } + // don't add a virtual destructor because we export this binary interface across dll's + virtual void Run( void *pvParam ) = 0; + virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) = 0; + int GetICallback() { return m_iCallback; } + virtual int GetCallbackSizeBytes() = 0; + +protected: + enum { k_ECallbackFlagsRegistered = 0x01, k_ECallbackFlagsGameServer = 0x02 }; + uint8 m_nCallbackFlags; + int m_iCallback; + friend class CCallbackMgr; + +private: + CCallbackBase( const CCallbackBase& ); + CCallbackBase& operator=( const CCallbackBase& ); +}; + +//----------------------------------------------------------------------------- +// Purpose: templated base for callbacks - internal implementation detail +//----------------------------------------------------------------------------- +template< int sizeof_P > +class CCallbackImpl : protected CCallbackBase +{ +public: + virtual ~CCallbackImpl() { if ( m_nCallbackFlags & k_ECallbackFlagsRegistered ) SteamAPI_UnregisterCallback( this ); } + void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; } + +protected: + friend class CCallbackMgr; + virtual void Run( void *pvParam ) S_OVERRIDE = 0; + virtual void Run( void *pvParam, bool /*bIOFailure*/, SteamAPICall_t /*hSteamAPICall*/ ) S_OVERRIDE { Run( pvParam ); } + virtual int GetCallbackSizeBytes() S_OVERRIDE { return sizeof_P; } +}; + + +//----------------------------------------------------------------------------- +// Purpose: maps a steam async call result to a class member function +// template params: T = local class, P = parameter struct +//----------------------------------------------------------------------------- +template< class T, class P > +class CCallResult : private CCallbackBase +{ +public: + typedef void (T::*func_t)( P*, bool ); + + CCallResult(); + ~CCallResult(); + + void Set( SteamAPICall_t hAPICall, T *p, func_t func ); + bool IsActive() const; + void Cancel(); + + void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; } +private: + virtual void Run( void *pvParam ) S_OVERRIDE; + virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) S_OVERRIDE; + virtual int GetCallbackSizeBytes() S_OVERRIDE { return sizeof( P ); } + + SteamAPICall_t m_hAPICall; + T *m_pObj; + func_t m_Func; +}; + + + +//----------------------------------------------------------------------------- +// Purpose: maps a steam callback to a class member function +// template params: T = local class, P = parameter struct, +// bGameserver = listen for gameserver callbacks instead of client callbacks +//----------------------------------------------------------------------------- +template< class T, class P, bool bGameserver = false > +class CCallback : public CCallbackImpl< sizeof( P ) > +{ +public: + typedef void (T::*func_t)(P*); + + // NOTE: If you can't provide the correct parameters at construction time, you should + // use the CCallbackManual callback object (STEAM_CALLBACK_MANUAL macro) instead. + CCallback( T *pObj, func_t func ); + + void Register( T *pObj, func_t func ); + void Unregister(); + +protected: + virtual void Run( void *pvParam ) S_OVERRIDE; + + T *m_pObj; + func_t m_Func; +}; + + +//----------------------------------------------------------------------------- +// Purpose: subclass of CCallback which allows default-construction in +// an unregistered state; you must call Register manually +//----------------------------------------------------------------------------- +template< class T, class P, bool bGameServer = false > +class CCallbackManual : public CCallback< T, P, bGameServer > +{ +public: + CCallbackManual() : CCallback< T, P, bGameServer >( nullptr, nullptr ) {} + + // Inherits public Register and Unregister functions from base class +}; + +// Internal implementation details for all of the above +#include "steam_api_internal.h" + +#endif // STEAM_API_COMMON_H diff --git a/lsteamclient/steamworks_sdk_160/steam_api_flat.h b/lsteamclient/steamworks_sdk_160/steam_api_flat.h new file mode 100644 index 0000000000..b948b94a7c --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steam_api_flat.h @@ -0,0 +1,1286 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Purpose: Header for "flat" SteamAPI. Use this for binding to other languages. +// This file is auto-generated, do not edit it. +// +//============================================================================= + +#ifndef STEAMAPIFLAT_H +#define STEAMAPIFLAT_H + +#include "steam/steam_api.h" +#include "steam/isteamgameserver.h" +#include "steam/isteamgameserverstats.h" + +typedef uint64 uint64_steamid; // Used when passing or returning CSteamID +typedef uint64 uint64_gameid; // Used when passing or return CGameID + + + +// ISteamClient +S_API HSteamPipe SteamAPI_ISteamClient_CreateSteamPipe( ISteamClient* self ); +S_API bool SteamAPI_ISteamClient_BReleaseSteamPipe( ISteamClient* self, HSteamPipe hSteamPipe ); +S_API HSteamUser SteamAPI_ISteamClient_ConnectToGlobalUser( ISteamClient* self, HSteamPipe hSteamPipe ); +S_API HSteamUser SteamAPI_ISteamClient_CreateLocalUser( ISteamClient* self, HSteamPipe * phSteamPipe, EAccountType eAccountType ); +S_API void SteamAPI_ISteamClient_ReleaseUser( ISteamClient* self, HSteamPipe hSteamPipe, HSteamUser hUser ); +S_API ISteamUser * SteamAPI_ISteamClient_GetISteamUser( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamGameServer * SteamAPI_ISteamClient_GetISteamGameServer( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API void SteamAPI_ISteamClient_SetLocalIPBinding( ISteamClient* self, const SteamIPAddress_t & unIP, uint16 usPort ); +S_API ISteamFriends * SteamAPI_ISteamClient_GetISteamFriends( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamUtils * SteamAPI_ISteamClient_GetISteamUtils( ISteamClient* self, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamMatchmaking * SteamAPI_ISteamClient_GetISteamMatchmaking( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamMatchmakingServers * SteamAPI_ISteamClient_GetISteamMatchmakingServers( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API void * SteamAPI_ISteamClient_GetISteamGenericInterface( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamUserStats * SteamAPI_ISteamClient_GetISteamUserStats( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamGameServerStats * SteamAPI_ISteamClient_GetISteamGameServerStats( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamApps * SteamAPI_ISteamClient_GetISteamApps( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamNetworking * SteamAPI_ISteamClient_GetISteamNetworking( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamRemoteStorage * SteamAPI_ISteamClient_GetISteamRemoteStorage( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamScreenshots * SteamAPI_ISteamClient_GetISteamScreenshots( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamGameSearch * SteamAPI_ISteamClient_GetISteamGameSearch( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API uint32 SteamAPI_ISteamClient_GetIPCCallCount( ISteamClient* self ); +S_API void SteamAPI_ISteamClient_SetWarningMessageHook( ISteamClient* self, SteamAPIWarningMessageHook_t pFunction ); +S_API bool SteamAPI_ISteamClient_BShutdownIfAllPipesClosed( ISteamClient* self ); +S_API ISteamHTTP * SteamAPI_ISteamClient_GetISteamHTTP( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamController * SteamAPI_ISteamClient_GetISteamController( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamUGC * SteamAPI_ISteamClient_GetISteamUGC( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamMusic * SteamAPI_ISteamClient_GetISteamMusic( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamMusicRemote * SteamAPI_ISteamClient_GetISteamMusicRemote( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamHTMLSurface * SteamAPI_ISteamClient_GetISteamHTMLSurface( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamInventory * SteamAPI_ISteamClient_GetISteamInventory( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamVideo * SteamAPI_ISteamClient_GetISteamVideo( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamParentalSettings * SteamAPI_ISteamClient_GetISteamParentalSettings( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamInput * SteamAPI_ISteamClient_GetISteamInput( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamParties * SteamAPI_ISteamClient_GetISteamParties( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); +S_API ISteamRemotePlay * SteamAPI_ISteamClient_GetISteamRemotePlay( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion ); + +// ISteamUser + +// A versioned accessor is exported by the library +S_API ISteamUser *SteamAPI_SteamUser_v023(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamUser(), but using this ensures that you are using a matching library. +inline ISteamUser *SteamAPI_SteamUser() { return SteamAPI_SteamUser_v023(); } +S_API HSteamUser SteamAPI_ISteamUser_GetHSteamUser( ISteamUser* self ); +S_API bool SteamAPI_ISteamUser_BLoggedOn( ISteamUser* self ); +S_API uint64_steamid SteamAPI_ISteamUser_GetSteamID( ISteamUser* self ); +S_API int SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED( ISteamUser* self, void * pAuthBlob, int cbMaxAuthBlob, uint64_steamid steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ); +S_API void SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED( ISteamUser* self, uint32 unIPServer, uint16 usPortServer ); +S_API void SteamAPI_ISteamUser_TrackAppUsageEvent( ISteamUser* self, uint64_gameid gameID, int eAppUsageEvent, const char * pchExtraInfo ); +S_API bool SteamAPI_ISteamUser_GetUserDataFolder( ISteamUser* self, char * pchBuffer, int cubBuffer ); +S_API void SteamAPI_ISteamUser_StartVoiceRecording( ISteamUser* self ); +S_API void SteamAPI_ISteamUser_StopVoiceRecording( ISteamUser* self ); +S_API EVoiceResult SteamAPI_ISteamUser_GetAvailableVoice( ISteamUser* self, uint32 * pcbCompressed, uint32 * pcbUncompressed_Deprecated, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated ); +S_API EVoiceResult SteamAPI_ISteamUser_GetVoice( ISteamUser* self, bool bWantCompressed, void * pDestBuffer, uint32 cbDestBufferSize, uint32 * nBytesWritten, bool bWantUncompressed_Deprecated, void * pUncompressedDestBuffer_Deprecated, uint32 cbUncompressedDestBufferSize_Deprecated, uint32 * nUncompressBytesWritten_Deprecated, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated ); +S_API EVoiceResult SteamAPI_ISteamUser_DecompressVoice( ISteamUser* self, const void * pCompressed, uint32 cbCompressed, void * pDestBuffer, uint32 cbDestBufferSize, uint32 * nBytesWritten, uint32 nDesiredSampleRate ); +S_API uint32 SteamAPI_ISteamUser_GetVoiceOptimalSampleRate( ISteamUser* self ); +S_API HAuthTicket SteamAPI_ISteamUser_GetAuthSessionTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSteamNetworkingIdentity ); +S_API HAuthTicket SteamAPI_ISteamUser_GetAuthTicketForWebApi( ISteamUser* self, const char * pchIdentity ); +S_API EBeginAuthSessionResult SteamAPI_ISteamUser_BeginAuthSession( ISteamUser* self, const void * pAuthTicket, int cbAuthTicket, uint64_steamid steamID ); +S_API void SteamAPI_ISteamUser_EndAuthSession( ISteamUser* self, uint64_steamid steamID ); +S_API void SteamAPI_ISteamUser_CancelAuthTicket( ISteamUser* self, HAuthTicket hAuthTicket ); +S_API EUserHasLicenseForAppResult SteamAPI_ISteamUser_UserHasLicenseForApp( ISteamUser* self, uint64_steamid steamID, AppId_t appID ); +S_API bool SteamAPI_ISteamUser_BIsBehindNAT( ISteamUser* self ); +S_API void SteamAPI_ISteamUser_AdvertiseGame( ISteamUser* self, uint64_steamid steamIDGameServer, uint32 unIPServer, uint16 usPortServer ); +S_API SteamAPICall_t SteamAPI_ISteamUser_RequestEncryptedAppTicket( ISteamUser* self, void * pDataToInclude, int cbDataToInclude ); +S_API bool SteamAPI_ISteamUser_GetEncryptedAppTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket ); +S_API int SteamAPI_ISteamUser_GetGameBadgeLevel( ISteamUser* self, int nSeries, bool bFoil ); +S_API int SteamAPI_ISteamUser_GetPlayerSteamLevel( ISteamUser* self ); +S_API SteamAPICall_t SteamAPI_ISteamUser_RequestStoreAuthURL( ISteamUser* self, const char * pchRedirectURL ); +S_API bool SteamAPI_ISteamUser_BIsPhoneVerified( ISteamUser* self ); +S_API bool SteamAPI_ISteamUser_BIsTwoFactorEnabled( ISteamUser* self ); +S_API bool SteamAPI_ISteamUser_BIsPhoneIdentifying( ISteamUser* self ); +S_API bool SteamAPI_ISteamUser_BIsPhoneRequiringVerification( ISteamUser* self ); +S_API SteamAPICall_t SteamAPI_ISteamUser_GetMarketEligibility( ISteamUser* self ); +S_API SteamAPICall_t SteamAPI_ISteamUser_GetDurationControl( ISteamUser* self ); +S_API bool SteamAPI_ISteamUser_BSetDurationControlOnlineState( ISteamUser* self, EDurationControlOnlineState eNewState ); + +// ISteamFriends + +// A versioned accessor is exported by the library +S_API ISteamFriends *SteamAPI_SteamFriends_v017(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamFriends(), but using this ensures that you are using a matching library. +inline ISteamFriends *SteamAPI_SteamFriends() { return SteamAPI_SteamFriends_v017(); } +S_API const char * SteamAPI_ISteamFriends_GetPersonaName( ISteamFriends* self ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_SetPersonaName( ISteamFriends* self, const char * pchPersonaName ); +S_API EPersonaState SteamAPI_ISteamFriends_GetPersonaState( ISteamFriends* self ); +S_API int SteamAPI_ISteamFriends_GetFriendCount( ISteamFriends* self, int iFriendFlags ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetFriendByIndex( ISteamFriends* self, int iFriend, int iFriendFlags ); +S_API EFriendRelationship SteamAPI_ISteamFriends_GetFriendRelationship( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API EPersonaState SteamAPI_ISteamFriends_GetFriendPersonaState( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API const char * SteamAPI_ISteamFriends_GetFriendPersonaName( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API bool SteamAPI_ISteamFriends_GetFriendGamePlayed( ISteamFriends* self, uint64_steamid steamIDFriend, FriendGameInfo_t * pFriendGameInfo ); +S_API const char * SteamAPI_ISteamFriends_GetFriendPersonaNameHistory( ISteamFriends* self, uint64_steamid steamIDFriend, int iPersonaName ); +S_API int SteamAPI_ISteamFriends_GetFriendSteamLevel( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API const char * SteamAPI_ISteamFriends_GetPlayerNickname( ISteamFriends* self, uint64_steamid steamIDPlayer ); +S_API int SteamAPI_ISteamFriends_GetFriendsGroupCount( ISteamFriends* self ); +S_API FriendsGroupID_t SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex( ISteamFriends* self, int iFG ); +S_API const char * SteamAPI_ISteamFriends_GetFriendsGroupName( ISteamFriends* self, FriendsGroupID_t friendsGroupID ); +S_API int SteamAPI_ISteamFriends_GetFriendsGroupMembersCount( ISteamFriends* self, FriendsGroupID_t friendsGroupID ); +S_API void SteamAPI_ISteamFriends_GetFriendsGroupMembersList( ISteamFriends* self, FriendsGroupID_t friendsGroupID, CSteamID * pOutSteamIDMembers, int nMembersCount ); +S_API bool SteamAPI_ISteamFriends_HasFriend( ISteamFriends* self, uint64_steamid steamIDFriend, int iFriendFlags ); +S_API int SteamAPI_ISteamFriends_GetClanCount( ISteamFriends* self ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetClanByIndex( ISteamFriends* self, int iClan ); +S_API const char * SteamAPI_ISteamFriends_GetClanName( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API const char * SteamAPI_ISteamFriends_GetClanTag( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API bool SteamAPI_ISteamFriends_GetClanActivityCounts( ISteamFriends* self, uint64_steamid steamIDClan, int * pnOnline, int * pnInGame, int * pnChatting ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_DownloadClanActivityCounts( ISteamFriends* self, CSteamID * psteamIDClans, int cClansToRequest ); +S_API int SteamAPI_ISteamFriends_GetFriendCountFromSource( ISteamFriends* self, uint64_steamid steamIDSource ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetFriendFromSourceByIndex( ISteamFriends* self, uint64_steamid steamIDSource, int iFriend ); +S_API bool SteamAPI_ISteamFriends_IsUserInSource( ISteamFriends* self, uint64_steamid steamIDUser, uint64_steamid steamIDSource ); +S_API void SteamAPI_ISteamFriends_SetInGameVoiceSpeaking( ISteamFriends* self, uint64_steamid steamIDUser, bool bSpeaking ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlay( ISteamFriends* self, const char * pchDialog ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayToUser( ISteamFriends* self, const char * pchDialog, uint64_steamid steamID ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( ISteamFriends* self, const char * pchURL, EActivateGameOverlayToWebPageMode eMode ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayToStore( ISteamFriends* self, AppId_t nAppID, EOverlayToStoreFlag eFlag ); +S_API void SteamAPI_ISteamFriends_SetPlayedWith( ISteamFriends* self, uint64_steamid steamIDUserPlayedWith ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog( ISteamFriends* self, uint64_steamid steamIDLobby ); +S_API int SteamAPI_ISteamFriends_GetSmallFriendAvatar( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API int SteamAPI_ISteamFriends_GetMediumFriendAvatar( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API int SteamAPI_ISteamFriends_GetLargeFriendAvatar( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API bool SteamAPI_ISteamFriends_RequestUserInformation( ISteamFriends* self, uint64_steamid steamIDUser, bool bRequireNameOnly ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_RequestClanOfficerList( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetClanOwner( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API int SteamAPI_ISteamFriends_GetClanOfficerCount( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetClanOfficerByIndex( ISteamFriends* self, uint64_steamid steamIDClan, int iOfficer ); +S_API uint32 SteamAPI_ISteamFriends_GetUserRestrictions( ISteamFriends* self ); +S_API bool SteamAPI_ISteamFriends_SetRichPresence( ISteamFriends* self, const char * pchKey, const char * pchValue ); +S_API void SteamAPI_ISteamFriends_ClearRichPresence( ISteamFriends* self ); +S_API const char * SteamAPI_ISteamFriends_GetFriendRichPresence( ISteamFriends* self, uint64_steamid steamIDFriend, const char * pchKey ); +S_API int SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API const char * SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex( ISteamFriends* self, uint64_steamid steamIDFriend, int iKey ); +S_API void SteamAPI_ISteamFriends_RequestFriendRichPresence( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API bool SteamAPI_ISteamFriends_InviteUserToGame( ISteamFriends* self, uint64_steamid steamIDFriend, const char * pchConnectString ); +S_API int SteamAPI_ISteamFriends_GetCoplayFriendCount( ISteamFriends* self ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetCoplayFriend( ISteamFriends* self, int iCoplayFriend ); +S_API int SteamAPI_ISteamFriends_GetFriendCoplayTime( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API AppId_t SteamAPI_ISteamFriends_GetFriendCoplayGame( ISteamFriends* self, uint64_steamid steamIDFriend ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_JoinClanChatRoom( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API bool SteamAPI_ISteamFriends_LeaveClanChatRoom( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API int SteamAPI_ISteamFriends_GetClanChatMemberCount( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API uint64_steamid SteamAPI_ISteamFriends_GetChatMemberByIndex( ISteamFriends* self, uint64_steamid steamIDClan, int iUser ); +S_API bool SteamAPI_ISteamFriends_SendClanChatMessage( ISteamFriends* self, uint64_steamid steamIDClanChat, const char * pchText ); +S_API int SteamAPI_ISteamFriends_GetClanChatMessage( ISteamFriends* self, uint64_steamid steamIDClanChat, int iMessage, void * prgchText, int cchTextMax, EChatEntryType * peChatEntryType, CSteamID * psteamidChatter ); +S_API bool SteamAPI_ISteamFriends_IsClanChatAdmin( ISteamFriends* self, uint64_steamid steamIDClanChat, uint64_steamid steamIDUser ); +S_API bool SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam( ISteamFriends* self, uint64_steamid steamIDClanChat ); +S_API bool SteamAPI_ISteamFriends_OpenClanChatWindowInSteam( ISteamFriends* self, uint64_steamid steamIDClanChat ); +S_API bool SteamAPI_ISteamFriends_CloseClanChatWindowInSteam( ISteamFriends* self, uint64_steamid steamIDClanChat ); +S_API bool SteamAPI_ISteamFriends_SetListenForFriendsMessages( ISteamFriends* self, bool bInterceptEnabled ); +S_API bool SteamAPI_ISteamFriends_ReplyToFriendMessage( ISteamFriends* self, uint64_steamid steamIDFriend, const char * pchMsgToSend ); +S_API int SteamAPI_ISteamFriends_GetFriendMessage( ISteamFriends* self, uint64_steamid steamIDFriend, int iMessageID, void * pvData, int cubData, EChatEntryType * peChatEntryType ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_GetFollowerCount( ISteamFriends* self, uint64_steamid steamID ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_IsFollowing( ISteamFriends* self, uint64_steamid steamID ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_EnumerateFollowingList( ISteamFriends* self, uint32 unStartIndex ); +S_API bool SteamAPI_ISteamFriends_IsClanPublic( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API bool SteamAPI_ISteamFriends_IsClanOfficialGameGroup( ISteamFriends* self, uint64_steamid steamIDClan ); +S_API int SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages( ISteamFriends* self ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog( ISteamFriends* self, uint64_steamid steamIDLobby ); +S_API bool SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser( ISteamFriends* self, const char * pchProtocol ); +S_API void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString( ISteamFriends* self, const char * pchConnectString ); +S_API SteamAPICall_t SteamAPI_ISteamFriends_RequestEquippedProfileItems( ISteamFriends* self, uint64_steamid steamID ); +S_API bool SteamAPI_ISteamFriends_BHasEquippedProfileItem( ISteamFriends* self, uint64_steamid steamID, ECommunityProfileItemType itemType ); +S_API const char * SteamAPI_ISteamFriends_GetProfileItemPropertyString( ISteamFriends* self, uint64_steamid steamID, ECommunityProfileItemType itemType, ECommunityProfileItemProperty prop ); +S_API uint32 SteamAPI_ISteamFriends_GetProfileItemPropertyUint( ISteamFriends* self, uint64_steamid steamID, ECommunityProfileItemType itemType, ECommunityProfileItemProperty prop ); + +// ISteamUtils + +// A versioned accessor is exported by the library +S_API ISteamUtils *SteamAPI_SteamUtils_v010(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamUtils(), but using this ensures that you are using a matching library. +inline ISteamUtils *SteamAPI_SteamUtils() { return SteamAPI_SteamUtils_v010(); } + +// A versioned accessor is exported by the library +S_API ISteamUtils *SteamAPI_SteamGameServerUtils_v010(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerUtils(), but using this ensures that you are using a matching library. +inline ISteamUtils *SteamAPI_SteamGameServerUtils() { return SteamAPI_SteamGameServerUtils_v010(); } +S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceAppActive( ISteamUtils* self ); +S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceComputerActive( ISteamUtils* self ); +S_API EUniverse SteamAPI_ISteamUtils_GetConnectedUniverse( ISteamUtils* self ); +S_API uint32 SteamAPI_ISteamUtils_GetServerRealTime( ISteamUtils* self ); +S_API const char * SteamAPI_ISteamUtils_GetIPCountry( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_GetImageSize( ISteamUtils* self, int iImage, uint32 * pnWidth, uint32 * pnHeight ); +S_API bool SteamAPI_ISteamUtils_GetImageRGBA( ISteamUtils* self, int iImage, uint8 * pubDest, int nDestBufferSize ); +S_API uint8 SteamAPI_ISteamUtils_GetCurrentBatteryPower( ISteamUtils* self ); +S_API uint32 SteamAPI_ISteamUtils_GetAppID( ISteamUtils* self ); +S_API void SteamAPI_ISteamUtils_SetOverlayNotificationPosition( ISteamUtils* self, ENotificationPosition eNotificationPosition ); +S_API bool SteamAPI_ISteamUtils_IsAPICallCompleted( ISteamUtils* self, SteamAPICall_t hSteamAPICall, bool * pbFailed ); +S_API ESteamAPICallFailure SteamAPI_ISteamUtils_GetAPICallFailureReason( ISteamUtils* self, SteamAPICall_t hSteamAPICall ); +S_API bool SteamAPI_ISteamUtils_GetAPICallResult( ISteamUtils* self, SteamAPICall_t hSteamAPICall, void * pCallback, int cubCallback, int iCallbackExpected, bool * pbFailed ); +S_API uint32 SteamAPI_ISteamUtils_GetIPCCallCount( ISteamUtils* self ); +S_API void SteamAPI_ISteamUtils_SetWarningMessageHook( ISteamUtils* self, SteamAPIWarningMessageHook_t pFunction ); +S_API bool SteamAPI_ISteamUtils_IsOverlayEnabled( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_BOverlayNeedsPresent( ISteamUtils* self ); +S_API SteamAPICall_t SteamAPI_ISteamUtils_CheckFileSignature( ISteamUtils* self, const char * szFileName ); +S_API bool SteamAPI_ISteamUtils_ShowGamepadTextInput( ISteamUtils* self, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32 unCharMax, const char * pchExistingText ); +S_API uint32 SteamAPI_ISteamUtils_GetEnteredGamepadTextLength( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_GetEnteredGamepadTextInput( ISteamUtils* self, char * pchText, uint32 cchText ); +S_API const char * SteamAPI_ISteamUtils_GetSteamUILanguage( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_IsSteamRunningInVR( ISteamUtils* self ); +S_API void SteamAPI_ISteamUtils_SetOverlayNotificationInset( ISteamUtils* self, int nHorizontalInset, int nVerticalInset ); +S_API bool SteamAPI_ISteamUtils_IsSteamInBigPictureMode( ISteamUtils* self ); +S_API void SteamAPI_ISteamUtils_StartVRDashboard( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled( ISteamUtils* self ); +S_API void SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled( ISteamUtils* self, bool bEnabled ); +S_API bool SteamAPI_ISteamUtils_IsSteamChinaLauncher( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_InitFilterText( ISteamUtils* self, uint32 unFilterOptions ); +S_API int SteamAPI_ISteamUtils_FilterText( ISteamUtils* self, ETextFilteringContext eContext, uint64_steamid sourceSteamID, const char * pchInputMessage, char * pchOutFilteredText, uint32 nByteSizeOutFilteredText ); +S_API ESteamIPv6ConnectivityState SteamAPI_ISteamUtils_GetIPv6ConnectivityState( ISteamUtils* self, ESteamIPv6ConnectivityProtocol eProtocol ); +S_API bool SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput( ISteamUtils* self, EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight ); +S_API void SteamAPI_ISteamUtils_SetGameLauncherMode( ISteamUtils* self, bool bLauncherMode ); +S_API bool SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput( ISteamUtils* self ); +S_API bool SteamAPI_ISteamUtils_DismissGamepadTextInput( ISteamUtils* self ); + +// ISteamMatchmaking + +// A versioned accessor is exported by the library +S_API ISteamMatchmaking *SteamAPI_SteamMatchmaking_v009(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamMatchmaking(), but using this ensures that you are using a matching library. +inline ISteamMatchmaking *SteamAPI_SteamMatchmaking() { return SteamAPI_SteamMatchmaking_v009(); } +S_API int SteamAPI_ISteamMatchmaking_GetFavoriteGameCount( ISteamMatchmaking* self ); +S_API bool SteamAPI_ISteamMatchmaking_GetFavoriteGame( ISteamMatchmaking* self, int iGame, AppId_t * pnAppID, uint32 * pnIP, uint16 * pnConnPort, uint16 * pnQueryPort, uint32 * punFlags, uint32 * pRTime32LastPlayedOnServer ); +S_API int SteamAPI_ISteamMatchmaking_AddFavoriteGame( ISteamMatchmaking* self, AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ); +S_API bool SteamAPI_ISteamMatchmaking_RemoveFavoriteGame( ISteamMatchmaking* self, AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ); +S_API SteamAPICall_t SteamAPI_ISteamMatchmaking_RequestLobbyList( ISteamMatchmaking* self ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter( ISteamMatchmaking* self, const char * pchKeyToMatch, const char * pchValueToMatch, ELobbyComparison eComparisonType ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter( ISteamMatchmaking* self, const char * pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter( ISteamMatchmaking* self, const char * pchKeyToMatch, int nValueToBeCloseTo ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable( ISteamMatchmaking* self, int nSlotsAvailable ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter( ISteamMatchmaking* self, ELobbyDistanceFilter eLobbyDistanceFilter ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter( ISteamMatchmaking* self, int cMaxResults ); +S_API void SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API uint64_steamid SteamAPI_ISteamMatchmaking_GetLobbyByIndex( ISteamMatchmaking* self, int iLobby ); +S_API SteamAPICall_t SteamAPI_ISteamMatchmaking_CreateLobby( ISteamMatchmaking* self, ELobbyType eLobbyType, int cMaxMembers ); +S_API SteamAPICall_t SteamAPI_ISteamMatchmaking_JoinLobby( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API void SteamAPI_ISteamMatchmaking_LeaveLobby( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API bool SteamAPI_ISteamMatchmaking_InviteUserToLobby( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint64_steamid steamIDInvitee ); +S_API int SteamAPI_ISteamMatchmaking_GetNumLobbyMembers( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API uint64_steamid SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex( ISteamMatchmaking* self, uint64_steamid steamIDLobby, int iMember ); +S_API const char * SteamAPI_ISteamMatchmaking_GetLobbyData( ISteamMatchmaking* self, uint64_steamid steamIDLobby, const char * pchKey ); +S_API bool SteamAPI_ISteamMatchmaking_SetLobbyData( ISteamMatchmaking* self, uint64_steamid steamIDLobby, const char * pchKey, const char * pchValue ); +S_API int SteamAPI_ISteamMatchmaking_GetLobbyDataCount( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API bool SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex( ISteamMatchmaking* self, uint64_steamid steamIDLobby, int iLobbyData, char * pchKey, int cchKeyBufferSize, char * pchValue, int cchValueBufferSize ); +S_API bool SteamAPI_ISteamMatchmaking_DeleteLobbyData( ISteamMatchmaking* self, uint64_steamid steamIDLobby, const char * pchKey ); +S_API const char * SteamAPI_ISteamMatchmaking_GetLobbyMemberData( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint64_steamid steamIDUser, const char * pchKey ); +S_API void SteamAPI_ISteamMatchmaking_SetLobbyMemberData( ISteamMatchmaking* self, uint64_steamid steamIDLobby, const char * pchKey, const char * pchValue ); +S_API bool SteamAPI_ISteamMatchmaking_SendLobbyChatMsg( ISteamMatchmaking* self, uint64_steamid steamIDLobby, const void * pvMsgBody, int cubMsgBody ); +S_API int SteamAPI_ISteamMatchmaking_GetLobbyChatEntry( ISteamMatchmaking* self, uint64_steamid steamIDLobby, int iChatID, CSteamID * pSteamIDUser, void * pvData, int cubData, EChatEntryType * peChatEntryType ); +S_API bool SteamAPI_ISteamMatchmaking_RequestLobbyData( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API void SteamAPI_ISteamMatchmaking_SetLobbyGameServer( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, uint64_steamid steamIDGameServer ); +S_API bool SteamAPI_ISteamMatchmaking_GetLobbyGameServer( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint32 * punGameServerIP, uint16 * punGameServerPort, CSteamID * psteamIDGameServer ); +S_API bool SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit( ISteamMatchmaking* self, uint64_steamid steamIDLobby, int cMaxMembers ); +S_API int SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API bool SteamAPI_ISteamMatchmaking_SetLobbyType( ISteamMatchmaking* self, uint64_steamid steamIDLobby, ELobbyType eLobbyType ); +S_API bool SteamAPI_ISteamMatchmaking_SetLobbyJoinable( ISteamMatchmaking* self, uint64_steamid steamIDLobby, bool bLobbyJoinable ); +S_API uint64_steamid SteamAPI_ISteamMatchmaking_GetLobbyOwner( ISteamMatchmaking* self, uint64_steamid steamIDLobby ); +S_API bool SteamAPI_ISteamMatchmaking_SetLobbyOwner( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint64_steamid steamIDNewOwner ); +S_API bool SteamAPI_ISteamMatchmaking_SetLinkedLobby( ISteamMatchmaking* self, uint64_steamid steamIDLobby, uint64_steamid steamIDLobbyDependent ); + +// ISteamMatchmakingServerListResponse +S_API void SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded( ISteamMatchmakingServerListResponse* self, HServerListRequest hRequest, int iServer ); +S_API void SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond( ISteamMatchmakingServerListResponse* self, HServerListRequest hRequest, int iServer ); +S_API void SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete( ISteamMatchmakingServerListResponse* self, HServerListRequest hRequest, EMatchMakingServerResponse response ); + +// ISteamMatchmakingPingResponse +S_API void SteamAPI_ISteamMatchmakingPingResponse_ServerResponded( ISteamMatchmakingPingResponse* self, gameserveritem_t & server ); +S_API void SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond( ISteamMatchmakingPingResponse* self ); + +// ISteamMatchmakingPlayersResponse +S_API void SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList( ISteamMatchmakingPlayersResponse* self, const char * pchName, int nScore, float flTimePlayed ); +S_API void SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond( ISteamMatchmakingPlayersResponse* self ); +S_API void SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete( ISteamMatchmakingPlayersResponse* self ); + +// ISteamMatchmakingRulesResponse +S_API void SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded( ISteamMatchmakingRulesResponse* self, const char * pchRule, const char * pchValue ); +S_API void SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond( ISteamMatchmakingRulesResponse* self ); +S_API void SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete( ISteamMatchmakingRulesResponse* self ); + +// ISteamMatchmakingServers + +// A versioned accessor is exported by the library +S_API ISteamMatchmakingServers *SteamAPI_SteamMatchmakingServers_v002(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamMatchmakingServers(), but using this ensures that you are using a matching library. +inline ISteamMatchmakingServers *SteamAPI_SteamMatchmakingServers() { return SteamAPI_SteamMatchmakingServers_v002(); } +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestInternetServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestLANServerList( ISteamMatchmakingServers* self, AppId_t iApp, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse ); +S_API void SteamAPI_ISteamMatchmakingServers_ReleaseRequest( ISteamMatchmakingServers* self, HServerListRequest hServerListRequest ); +S_API gameserveritem_t * SteamAPI_ISteamMatchmakingServers_GetServerDetails( ISteamMatchmakingServers* self, HServerListRequest hRequest, int iServer ); +S_API void SteamAPI_ISteamMatchmakingServers_CancelQuery( ISteamMatchmakingServers* self, HServerListRequest hRequest ); +S_API void SteamAPI_ISteamMatchmakingServers_RefreshQuery( ISteamMatchmakingServers* self, HServerListRequest hRequest ); +S_API bool SteamAPI_ISteamMatchmakingServers_IsRefreshing( ISteamMatchmakingServers* self, HServerListRequest hRequest ); +S_API int SteamAPI_ISteamMatchmakingServers_GetServerCount( ISteamMatchmakingServers* self, HServerListRequest hRequest ); +S_API void SteamAPI_ISteamMatchmakingServers_RefreshServer( ISteamMatchmakingServers* self, HServerListRequest hRequest, int iServer ); +S_API HServerQuery SteamAPI_ISteamMatchmakingServers_PingServer( ISteamMatchmakingServers* self, uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse * pRequestServersResponse ); +S_API HServerQuery SteamAPI_ISteamMatchmakingServers_PlayerDetails( ISteamMatchmakingServers* self, uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse * pRequestServersResponse ); +S_API HServerQuery SteamAPI_ISteamMatchmakingServers_ServerRules( ISteamMatchmakingServers* self, uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse * pRequestServersResponse ); +S_API void SteamAPI_ISteamMatchmakingServers_CancelServerQuery( ISteamMatchmakingServers* self, HServerQuery hServerQuery ); + +// ISteamGameSearch + +// A versioned accessor is exported by the library +S_API ISteamGameSearch *SteamAPI_SteamGameSearch_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameSearch(), but using this ensures that you are using a matching library. +inline ISteamGameSearch *SteamAPI_SteamGameSearch() { return SteamAPI_SteamGameSearch_v001(); } +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_AddGameSearchParams( ISteamGameSearch* self, const char * pchKeyToFind, const char * pchValuesToFind ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SearchForGameWithLobby( ISteamGameSearch* self, uint64_steamid steamIDLobby, int nPlayerMin, int nPlayerMax ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SearchForGameSolo( ISteamGameSearch* self, int nPlayerMin, int nPlayerMax ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_AcceptGame( ISteamGameSearch* self ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_DeclineGame( ISteamGameSearch* self ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_RetrieveConnectionDetails( ISteamGameSearch* self, uint64_steamid steamIDHost, char * pchConnectionDetails, int cubConnectionDetails ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_EndGameSearch( ISteamGameSearch* self ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SetGameHostParams( ISteamGameSearch* self, const char * pchKey, const char * pchValue ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SetConnectionDetails( ISteamGameSearch* self, const char * pchConnectionDetails, int cubConnectionDetails ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_RequestPlayersForGame( ISteamGameSearch* self, int nPlayerMin, int nPlayerMax, int nMaxTeamSize ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_HostConfirmGameStart( ISteamGameSearch* self, uint64 ullUniqueGameID ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame( ISteamGameSearch* self ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SubmitPlayerResult( ISteamGameSearch* self, uint64 ullUniqueGameID, uint64_steamid steamIDPlayer, EPlayerResult_t EPlayerResult ); +S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_EndGame( ISteamGameSearch* self, uint64 ullUniqueGameID ); + +// ISteamParties + +// A versioned accessor is exported by the library +S_API ISteamParties *SteamAPI_SteamParties_v002(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamParties(), but using this ensures that you are using a matching library. +inline ISteamParties *SteamAPI_SteamParties() { return SteamAPI_SteamParties_v002(); } +S_API uint32 SteamAPI_ISteamParties_GetNumActiveBeacons( ISteamParties* self ); +S_API PartyBeaconID_t SteamAPI_ISteamParties_GetBeaconByIndex( ISteamParties* self, uint32 unIndex ); +S_API bool SteamAPI_ISteamParties_GetBeaconDetails( ISteamParties* self, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, SteamPartyBeaconLocation_t * pLocation, char * pchMetadata, int cchMetadata ); +S_API SteamAPICall_t SteamAPI_ISteamParties_JoinParty( ISteamParties* self, PartyBeaconID_t ulBeaconID ); +S_API bool SteamAPI_ISteamParties_GetNumAvailableBeaconLocations( ISteamParties* self, uint32 * puNumLocations ); +S_API bool SteamAPI_ISteamParties_GetAvailableBeaconLocations( ISteamParties* self, SteamPartyBeaconLocation_t * pLocationList, uint32 uMaxNumLocations ); +S_API SteamAPICall_t SteamAPI_ISteamParties_CreateBeacon( ISteamParties* self, uint32 unOpenSlots, SteamPartyBeaconLocation_t * pBeaconLocation, const char * pchConnectString, const char * pchMetadata ); +S_API void SteamAPI_ISteamParties_OnReservationCompleted( ISteamParties* self, PartyBeaconID_t ulBeacon, uint64_steamid steamIDUser ); +S_API void SteamAPI_ISteamParties_CancelReservation( ISteamParties* self, PartyBeaconID_t ulBeacon, uint64_steamid steamIDUser ); +S_API SteamAPICall_t SteamAPI_ISteamParties_ChangeNumOpenSlots( ISteamParties* self, PartyBeaconID_t ulBeacon, uint32 unOpenSlots ); +S_API bool SteamAPI_ISteamParties_DestroyBeacon( ISteamParties* self, PartyBeaconID_t ulBeacon ); +S_API bool SteamAPI_ISteamParties_GetBeaconLocationData( ISteamParties* self, SteamPartyBeaconLocation_t BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut ); + +// ISteamRemoteStorage + +// A versioned accessor is exported by the library +S_API ISteamRemoteStorage *SteamAPI_SteamRemoteStorage_v016(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamRemoteStorage(), but using this ensures that you are using a matching library. +inline ISteamRemoteStorage *SteamAPI_SteamRemoteStorage() { return SteamAPI_SteamRemoteStorage_v016(); } +S_API bool SteamAPI_ISteamRemoteStorage_FileWrite( ISteamRemoteStorage* self, const char * pchFile, const void * pvData, int32 cubData ); +S_API int32 SteamAPI_ISteamRemoteStorage_FileRead( ISteamRemoteStorage* self, const char * pchFile, void * pvData, int32 cubDataToRead ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileWriteAsync( ISteamRemoteStorage* self, const char * pchFile, const void * pvData, uint32 cubData ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileReadAsync( ISteamRemoteStorage* self, const char * pchFile, uint32 nOffset, uint32 cubToRead ); +S_API bool SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete( ISteamRemoteStorage* self, SteamAPICall_t hReadCall, void * pvBuffer, uint32 cubToRead ); +S_API bool SteamAPI_ISteamRemoteStorage_FileForget( ISteamRemoteStorage* self, const char * pchFile ); +S_API bool SteamAPI_ISteamRemoteStorage_FileDelete( ISteamRemoteStorage* self, const char * pchFile ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileShare( ISteamRemoteStorage* self, const char * pchFile ); +S_API bool SteamAPI_ISteamRemoteStorage_SetSyncPlatforms( ISteamRemoteStorage* self, const char * pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ); +S_API UGCFileWriteStreamHandle_t SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen( ISteamRemoteStorage* self, const char * pchFile ); +S_API bool SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk( ISteamRemoteStorage* self, UGCFileWriteStreamHandle_t writeHandle, const void * pvData, int32 cubData ); +S_API bool SteamAPI_ISteamRemoteStorage_FileWriteStreamClose( ISteamRemoteStorage* self, UGCFileWriteStreamHandle_t writeHandle ); +S_API bool SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel( ISteamRemoteStorage* self, UGCFileWriteStreamHandle_t writeHandle ); +S_API bool SteamAPI_ISteamRemoteStorage_FileExists( ISteamRemoteStorage* self, const char * pchFile ); +S_API bool SteamAPI_ISteamRemoteStorage_FilePersisted( ISteamRemoteStorage* self, const char * pchFile ); +S_API int32 SteamAPI_ISteamRemoteStorage_GetFileSize( ISteamRemoteStorage* self, const char * pchFile ); +S_API int64 SteamAPI_ISteamRemoteStorage_GetFileTimestamp( ISteamRemoteStorage* self, const char * pchFile ); +S_API ERemoteStoragePlatform SteamAPI_ISteamRemoteStorage_GetSyncPlatforms( ISteamRemoteStorage* self, const char * pchFile ); +S_API int32 SteamAPI_ISteamRemoteStorage_GetFileCount( ISteamRemoteStorage* self ); +S_API const char * SteamAPI_ISteamRemoteStorage_GetFileNameAndSize( ISteamRemoteStorage* self, int iFile, int32 * pnFileSizeInBytes ); +S_API bool SteamAPI_ISteamRemoteStorage_GetQuota( ISteamRemoteStorage* self, uint64 * pnTotalBytes, uint64 * puAvailableBytes ); +S_API bool SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount( ISteamRemoteStorage* self ); +S_API bool SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp( ISteamRemoteStorage* self ); +S_API void SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp( ISteamRemoteStorage* self, bool bEnabled ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_UGCDownload( ISteamRemoteStorage* self, UGCHandle_t hContent, uint32 unPriority ); +S_API bool SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress( ISteamRemoteStorage* self, UGCHandle_t hContent, int32 * pnBytesDownloaded, int32 * pnBytesExpected ); +S_API bool SteamAPI_ISteamRemoteStorage_GetUGCDetails( ISteamRemoteStorage* self, UGCHandle_t hContent, AppId_t * pnAppID, char ** ppchName, int32 * pnFileSizeInBytes, CSteamID * pSteamIDOwner ); +S_API int32 SteamAPI_ISteamRemoteStorage_UGCRead( ISteamRemoteStorage* self, UGCHandle_t hContent, void * pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction ); +S_API int32 SteamAPI_ISteamRemoteStorage_GetCachedUGCCount( ISteamRemoteStorage* self ); +S_API UGCHandle_t SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle( ISteamRemoteStorage* self, int32 iCachedContent ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_PublishWorkshopFile( ISteamRemoteStorage* self, const char * pchFile, const char * pchPreviewFile, AppId_t nConsumerAppId, const char * pchTitle, const char * pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t * pTags, EWorkshopFileType eWorkshopFileType ); +S_API PublishedFileUpdateHandle_t SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, const char * pchFile ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, const char * pchPreviewFile ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, const char * pchTitle ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, const char * pchDescription ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t * pTags ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_DeletePublishedFile( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles( ISteamRemoteStorage* self, uint32 unStartIndex ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_SubscribePublishedFile( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles( ISteamRemoteStorage* self, uint32 unStartIndex ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API bool SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription( ISteamRemoteStorage* self, PublishedFileUpdateHandle_t updateHandle, const char * pchChangeDescription ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId, bool bVoteUp ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles( ISteamRemoteStorage* self, uint64_steamid steamId, uint32 unStartIndex, SteamParamStringArray_t * pRequiredTags, SteamParamStringArray_t * pExcludedTags ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_PublishVideo( ISteamRemoteStorage* self, EWorkshopVideoProvider eVideoProvider, const char * pchVideoAccount, const char * pchVideoIdentifier, const char * pchPreviewFile, AppId_t nConsumerAppId, const char * pchTitle, const char * pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t * pTags ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction( ISteamRemoteStorage* self, PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction( ISteamRemoteStorage* self, EWorkshopFileAction eAction, uint32 unStartIndex ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles( ISteamRemoteStorage* self, EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t * pTags, SteamParamStringArray_t * pUserTags ); +S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation( ISteamRemoteStorage* self, UGCHandle_t hContent, const char * pchLocation, uint32 unPriority ); +S_API int32 SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount( ISteamRemoteStorage* self ); +S_API const char * SteamAPI_ISteamRemoteStorage_GetLocalFileChange( ISteamRemoteStorage* self, int iFile, ERemoteStorageLocalFileChange * pEChangeType, ERemoteStorageFilePathType * pEFilePathType ); +S_API bool SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch( ISteamRemoteStorage* self ); +S_API bool SteamAPI_ISteamRemoteStorage_EndFileWriteBatch( ISteamRemoteStorage* self ); + +// ISteamUserStats + +// A versioned accessor is exported by the library +S_API ISteamUserStats *SteamAPI_SteamUserStats_v012(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamUserStats(), but using this ensures that you are using a matching library. +inline ISteamUserStats *SteamAPI_SteamUserStats() { return SteamAPI_SteamUserStats_v012(); } +S_API bool SteamAPI_ISteamUserStats_RequestCurrentStats( ISteamUserStats* self ); +S_API bool SteamAPI_ISteamUserStats_GetStatInt32( ISteamUserStats* self, const char * pchName, int32 * pData ); +S_API bool SteamAPI_ISteamUserStats_GetStatFloat( ISteamUserStats* self, const char * pchName, float * pData ); +S_API bool SteamAPI_ISteamUserStats_SetStatInt32( ISteamUserStats* self, const char * pchName, int32 nData ); +S_API bool SteamAPI_ISteamUserStats_SetStatFloat( ISteamUserStats* self, const char * pchName, float fData ); +S_API bool SteamAPI_ISteamUserStats_UpdateAvgRateStat( ISteamUserStats* self, const char * pchName, float flCountThisSession, double dSessionLength ); +S_API bool SteamAPI_ISteamUserStats_GetAchievement( ISteamUserStats* self, const char * pchName, bool * pbAchieved ); +S_API bool SteamAPI_ISteamUserStats_SetAchievement( ISteamUserStats* self, const char * pchName ); +S_API bool SteamAPI_ISteamUserStats_ClearAchievement( ISteamUserStats* self, const char * pchName ); +S_API bool SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime( ISteamUserStats* self, const char * pchName, bool * pbAchieved, uint32 * punUnlockTime ); +S_API bool SteamAPI_ISteamUserStats_StoreStats( ISteamUserStats* self ); +S_API int SteamAPI_ISteamUserStats_GetAchievementIcon( ISteamUserStats* self, const char * pchName ); +S_API const char * SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute( ISteamUserStats* self, const char * pchName, const char * pchKey ); +S_API bool SteamAPI_ISteamUserStats_IndicateAchievementProgress( ISteamUserStats* self, const char * pchName, uint32 nCurProgress, uint32 nMaxProgress ); +S_API uint32 SteamAPI_ISteamUserStats_GetNumAchievements( ISteamUserStats* self ); +S_API const char * SteamAPI_ISteamUserStats_GetAchievementName( ISteamUserStats* self, uint32 iAchievement ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_RequestUserStats( ISteamUserStats* self, uint64_steamid steamIDUser ); +S_API bool SteamAPI_ISteamUserStats_GetUserStatInt32( ISteamUserStats* self, uint64_steamid steamIDUser, const char * pchName, int32 * pData ); +S_API bool SteamAPI_ISteamUserStats_GetUserStatFloat( ISteamUserStats* self, uint64_steamid steamIDUser, const char * pchName, float * pData ); +S_API bool SteamAPI_ISteamUserStats_GetUserAchievement( ISteamUserStats* self, uint64_steamid steamIDUser, const char * pchName, bool * pbAchieved ); +S_API bool SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* self, uint64_steamid steamIDUser, const char * pchName, bool * pbAchieved, uint32 * punUnlockTime ); +S_API bool SteamAPI_ISteamUserStats_ResetAllStats( ISteamUserStats* self, bool bAchievementsToo ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_FindOrCreateLeaderboard( ISteamUserStats* self, const char * pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_FindLeaderboard( ISteamUserStats* self, const char * pchLeaderboardName ); +S_API const char * SteamAPI_ISteamUserStats_GetLeaderboardName( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard ); +S_API int SteamAPI_ISteamUserStats_GetLeaderboardEntryCount( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard ); +S_API ELeaderboardSortMethod SteamAPI_ISteamUserStats_GetLeaderboardSortMethod( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard ); +S_API ELeaderboardDisplayType SteamAPI_ISteamUserStats_GetLeaderboardDisplayType( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_DownloadLeaderboardEntries( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, CSteamID * prgUsers, int cUsers ); +S_API bool SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t * pLeaderboardEntry, int32 * pDetails, int cDetailsMax ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_UploadLeaderboardScore( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 * pScoreDetails, int cScoreDetailsCount ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_AttachLeaderboardUGC( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers( ISteamUserStats* self ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages( ISteamUserStats* self ); +S_API int SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo( ISteamUserStats* self, char * pchName, uint32 unNameBufLen, float * pflPercent, bool * pbAchieved ); +S_API int SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* self, int iIteratorPrevious, char * pchName, uint32 unNameBufLen, float * pflPercent, bool * pbAchieved ); +S_API bool SteamAPI_ISteamUserStats_GetAchievementAchievedPercent( ISteamUserStats* self, const char * pchName, float * pflPercent ); +S_API SteamAPICall_t SteamAPI_ISteamUserStats_RequestGlobalStats( ISteamUserStats* self, int nHistoryDays ); +S_API bool SteamAPI_ISteamUserStats_GetGlobalStatInt64( ISteamUserStats* self, const char * pchStatName, int64 * pData ); +S_API bool SteamAPI_ISteamUserStats_GetGlobalStatDouble( ISteamUserStats* self, const char * pchStatName, double * pData ); +S_API int32 SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64( ISteamUserStats* self, const char * pchStatName, int64 * pData, uint32 cubData ); +S_API int32 SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble( ISteamUserStats* self, const char * pchStatName, double * pData, uint32 cubData ); +S_API bool SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32( ISteamUserStats* self, const char * pchName, int32 * pnMinProgress, int32 * pnMaxProgress ); +S_API bool SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat( ISteamUserStats* self, const char * pchName, float * pfMinProgress, float * pfMaxProgress ); + +// ISteamApps + +// A versioned accessor is exported by the library +S_API ISteamApps *SteamAPI_SteamApps_v008(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamApps(), but using this ensures that you are using a matching library. +inline ISteamApps *SteamAPI_SteamApps() { return SteamAPI_SteamApps_v008(); } +S_API bool SteamAPI_ISteamApps_BIsSubscribed( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BIsLowViolence( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BIsCybercafe( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BIsVACBanned( ISteamApps* self ); +S_API const char * SteamAPI_ISteamApps_GetCurrentGameLanguage( ISteamApps* self ); +S_API const char * SteamAPI_ISteamApps_GetAvailableGameLanguages( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BIsSubscribedApp( ISteamApps* self, AppId_t appID ); +S_API bool SteamAPI_ISteamApps_BIsDlcInstalled( ISteamApps* self, AppId_t appID ); +S_API uint32 SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime( ISteamApps* self, AppId_t nAppID ); +S_API bool SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend( ISteamApps* self ); +S_API int SteamAPI_ISteamApps_GetDLCCount( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BGetDLCDataByIndex( ISteamApps* self, int iDLC, AppId_t * pAppID, bool * pbAvailable, char * pchName, int cchNameBufferSize ); +S_API void SteamAPI_ISteamApps_InstallDLC( ISteamApps* self, AppId_t nAppID ); +S_API void SteamAPI_ISteamApps_UninstallDLC( ISteamApps* self, AppId_t nAppID ); +S_API void SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey( ISteamApps* self, AppId_t nAppID ); +S_API bool SteamAPI_ISteamApps_GetCurrentBetaName( ISteamApps* self, char * pchName, int cchNameBufferSize ); +S_API bool SteamAPI_ISteamApps_MarkContentCorrupt( ISteamApps* self, bool bMissingFilesOnly ); +S_API uint32 SteamAPI_ISteamApps_GetInstalledDepots( ISteamApps* self, AppId_t appID, DepotId_t * pvecDepots, uint32 cMaxDepots ); +S_API uint32 SteamAPI_ISteamApps_GetAppInstallDir( ISteamApps* self, AppId_t appID, char * pchFolder, uint32 cchFolderBufferSize ); +S_API bool SteamAPI_ISteamApps_BIsAppInstalled( ISteamApps* self, AppId_t appID ); +S_API uint64_steamid SteamAPI_ISteamApps_GetAppOwner( ISteamApps* self ); +S_API const char * SteamAPI_ISteamApps_GetLaunchQueryParam( ISteamApps* self, const char * pchKey ); +S_API bool SteamAPI_ISteamApps_GetDlcDownloadProgress( ISteamApps* self, AppId_t nAppID, uint64 * punBytesDownloaded, uint64 * punBytesTotal ); +S_API int SteamAPI_ISteamApps_GetAppBuildId( ISteamApps* self ); +S_API void SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys( ISteamApps* self ); +S_API SteamAPICall_t SteamAPI_ISteamApps_GetFileDetails( ISteamApps* self, const char * pszFileName ); +S_API int SteamAPI_ISteamApps_GetLaunchCommandLine( ISteamApps* self, char * pszCommandLine, int cubCommandLine ); +S_API bool SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing( ISteamApps* self ); +S_API bool SteamAPI_ISteamApps_BIsTimedTrial( ISteamApps* self, uint32 * punSecondsAllowed, uint32 * punSecondsPlayed ); +S_API bool SteamAPI_ISteamApps_SetDlcContext( ISteamApps* self, AppId_t nAppID ); +S_API int SteamAPI_ISteamApps_GetNumBetas( ISteamApps* self, AppId_t unAppID, int * pnAvailable, int * pnPrivate ); +S_API bool SteamAPI_ISteamApps_GetBetaInfo( ISteamApps* self, AppId_t unAppID, int iBetaIndex, uint32 * punFlags, uint32 * punBuildID, char * pchBetaName, int cchBetaName, char * pchDescription, int cchDescription ); +S_API bool SteamAPI_ISteamApps_SetActiveBeta( ISteamApps* self, AppId_t unAppID, const char * pchBetaName ); + +// ISteamNetworking + +// A versioned accessor is exported by the library +S_API ISteamNetworking *SteamAPI_SteamNetworking_v006(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworking(), but using this ensures that you are using a matching library. +inline ISteamNetworking *SteamAPI_SteamNetworking() { return SteamAPI_SteamNetworking_v006(); } + +// A versioned accessor is exported by the library +S_API ISteamNetworking *SteamAPI_SteamGameServerNetworking_v006(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworking(), but using this ensures that you are using a matching library. +inline ISteamNetworking *SteamAPI_SteamGameServerNetworking() { return SteamAPI_SteamGameServerNetworking_v006(); } +S_API bool SteamAPI_ISteamNetworking_SendP2PPacket( ISteamNetworking* self, uint64_steamid steamIDRemote, const void * pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel ); +S_API bool SteamAPI_ISteamNetworking_IsP2PPacketAvailable( ISteamNetworking* self, uint32 * pcubMsgSize, int nChannel ); +S_API bool SteamAPI_ISteamNetworking_ReadP2PPacket( ISteamNetworking* self, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, CSteamID * psteamIDRemote, int nChannel ); +S_API bool SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser( ISteamNetworking* self, uint64_steamid steamIDRemote ); +S_API bool SteamAPI_ISteamNetworking_CloseP2PSessionWithUser( ISteamNetworking* self, uint64_steamid steamIDRemote ); +S_API bool SteamAPI_ISteamNetworking_CloseP2PChannelWithUser( ISteamNetworking* self, uint64_steamid steamIDRemote, int nChannel ); +S_API bool SteamAPI_ISteamNetworking_GetP2PSessionState( ISteamNetworking* self, uint64_steamid steamIDRemote, P2PSessionState_t * pConnectionState ); +S_API bool SteamAPI_ISteamNetworking_AllowP2PPacketRelay( ISteamNetworking* self, bool bAllow ); +S_API SNetListenSocket_t SteamAPI_ISteamNetworking_CreateListenSocket( ISteamNetworking* self, int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay ); +S_API SNetSocket_t SteamAPI_ISteamNetworking_CreateP2PConnectionSocket( ISteamNetworking* self, uint64_steamid steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay ); +S_API SNetSocket_t SteamAPI_ISteamNetworking_CreateConnectionSocket( ISteamNetworking* self, SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec ); +S_API bool SteamAPI_ISteamNetworking_DestroySocket( ISteamNetworking* self, SNetSocket_t hSocket, bool bNotifyRemoteEnd ); +S_API bool SteamAPI_ISteamNetworking_DestroyListenSocket( ISteamNetworking* self, SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ); +S_API bool SteamAPI_ISteamNetworking_SendDataOnSocket( ISteamNetworking* self, SNetSocket_t hSocket, void * pubData, uint32 cubData, bool bReliable ); +S_API bool SteamAPI_ISteamNetworking_IsDataAvailableOnSocket( ISteamNetworking* self, SNetSocket_t hSocket, uint32 * pcubMsgSize ); +S_API bool SteamAPI_ISteamNetworking_RetrieveDataFromSocket( ISteamNetworking* self, SNetSocket_t hSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize ); +S_API bool SteamAPI_ISteamNetworking_IsDataAvailable( ISteamNetworking* self, SNetListenSocket_t hListenSocket, uint32 * pcubMsgSize, SNetSocket_t * phSocket ); +S_API bool SteamAPI_ISteamNetworking_RetrieveData( ISteamNetworking* self, SNetListenSocket_t hListenSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, SNetSocket_t * phSocket ); +S_API bool SteamAPI_ISteamNetworking_GetSocketInfo( ISteamNetworking* self, SNetSocket_t hSocket, CSteamID * pSteamIDRemote, int * peSocketStatus, SteamIPAddress_t * punIPRemote, uint16 * punPortRemote ); +S_API bool SteamAPI_ISteamNetworking_GetListenSocketInfo( ISteamNetworking* self, SNetListenSocket_t hListenSocket, SteamIPAddress_t * pnIP, uint16 * pnPort ); +S_API ESNetSocketConnectionType SteamAPI_ISteamNetworking_GetSocketConnectionType( ISteamNetworking* self, SNetSocket_t hSocket ); +S_API int SteamAPI_ISteamNetworking_GetMaxPacketSize( ISteamNetworking* self, SNetSocket_t hSocket ); + +// ISteamScreenshots + +// A versioned accessor is exported by the library +S_API ISteamScreenshots *SteamAPI_SteamScreenshots_v003(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamScreenshots(), but using this ensures that you are using a matching library. +inline ISteamScreenshots *SteamAPI_SteamScreenshots() { return SteamAPI_SteamScreenshots_v003(); } +S_API ScreenshotHandle SteamAPI_ISteamScreenshots_WriteScreenshot( ISteamScreenshots* self, void * pubRGB, uint32 cubRGB, int nWidth, int nHeight ); +S_API ScreenshotHandle SteamAPI_ISteamScreenshots_AddScreenshotToLibrary( ISteamScreenshots* self, const char * pchFilename, const char * pchThumbnailFilename, int nWidth, int nHeight ); +S_API void SteamAPI_ISteamScreenshots_TriggerScreenshot( ISteamScreenshots* self ); +S_API void SteamAPI_ISteamScreenshots_HookScreenshots( ISteamScreenshots* self, bool bHook ); +S_API bool SteamAPI_ISteamScreenshots_SetLocation( ISteamScreenshots* self, ScreenshotHandle hScreenshot, const char * pchLocation ); +S_API bool SteamAPI_ISteamScreenshots_TagUser( ISteamScreenshots* self, ScreenshotHandle hScreenshot, uint64_steamid steamID ); +S_API bool SteamAPI_ISteamScreenshots_TagPublishedFile( ISteamScreenshots* self, ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ); +S_API bool SteamAPI_ISteamScreenshots_IsScreenshotsHooked( ISteamScreenshots* self ); +S_API ScreenshotHandle SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary( ISteamScreenshots* self, EVRScreenshotType eType, const char * pchFilename, const char * pchVRFilename ); + +// ISteamMusic + +// A versioned accessor is exported by the library +S_API ISteamMusic *SteamAPI_SteamMusic_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamMusic(), but using this ensures that you are using a matching library. +inline ISteamMusic *SteamAPI_SteamMusic() { return SteamAPI_SteamMusic_v001(); } +S_API bool SteamAPI_ISteamMusic_BIsEnabled( ISteamMusic* self ); +S_API bool SteamAPI_ISteamMusic_BIsPlaying( ISteamMusic* self ); +S_API AudioPlayback_Status SteamAPI_ISteamMusic_GetPlaybackStatus( ISteamMusic* self ); +S_API void SteamAPI_ISteamMusic_Play( ISteamMusic* self ); +S_API void SteamAPI_ISteamMusic_Pause( ISteamMusic* self ); +S_API void SteamAPI_ISteamMusic_PlayPrevious( ISteamMusic* self ); +S_API void SteamAPI_ISteamMusic_PlayNext( ISteamMusic* self ); +S_API void SteamAPI_ISteamMusic_SetVolume( ISteamMusic* self, float flVolume ); +S_API float SteamAPI_ISteamMusic_GetVolume( ISteamMusic* self ); + +// ISteamMusicRemote + +// A versioned accessor is exported by the library +S_API ISteamMusicRemote *SteamAPI_SteamMusicRemote_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamMusicRemote(), but using this ensures that you are using a matching library. +inline ISteamMusicRemote *SteamAPI_SteamMusicRemote() { return SteamAPI_SteamMusicRemote_v001(); } +S_API bool SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote( ISteamMusicRemote* self, const char * pchName ); +S_API bool SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_BActivationSuccess( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_SetDisplayName( ISteamMusicRemote* self, const char * pchDisplayName ); +S_API bool SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64( ISteamMusicRemote* self, void * pvBuffer, uint32 cbBufferLength ); +S_API bool SteamAPI_ISteamMusicRemote_EnablePlayPrevious( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_EnablePlayNext( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_EnableShuffled( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_EnableLooped( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_EnableQueue( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_EnablePlaylists( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus( ISteamMusicRemote* self, AudioPlayback_Status nStatus ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateShuffled( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateLooped( ISteamMusicRemote* self, bool bValue ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateVolume( ISteamMusicRemote* self, float flValue ); +S_API bool SteamAPI_ISteamMusicRemote_CurrentEntryWillChange( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable( ISteamMusicRemote* self, bool bAvailable ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText( ISteamMusicRemote* self, const char * pchText ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds( ISteamMusicRemote* self, int nValue ); +S_API bool SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt( ISteamMusicRemote* self, void * pvBuffer, uint32 cbBufferLength ); +S_API bool SteamAPI_ISteamMusicRemote_CurrentEntryDidChange( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_QueueWillChange( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_ResetQueueEntries( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_SetQueueEntry( ISteamMusicRemote* self, int nID, int nPosition, const char * pchEntryText ); +S_API bool SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry( ISteamMusicRemote* self, int nID ); +S_API bool SteamAPI_ISteamMusicRemote_QueueDidChange( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_PlaylistWillChange( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_ResetPlaylistEntries( ISteamMusicRemote* self ); +S_API bool SteamAPI_ISteamMusicRemote_SetPlaylistEntry( ISteamMusicRemote* self, int nID, int nPosition, const char * pchEntryText ); +S_API bool SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry( ISteamMusicRemote* self, int nID ); +S_API bool SteamAPI_ISteamMusicRemote_PlaylistDidChange( ISteamMusicRemote* self ); + +// ISteamHTTP + +// A versioned accessor is exported by the library +S_API ISteamHTTP *SteamAPI_SteamHTTP_v003(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamHTTP(), but using this ensures that you are using a matching library. +inline ISteamHTTP *SteamAPI_SteamHTTP() { return SteamAPI_SteamHTTP_v003(); } + +// A versioned accessor is exported by the library +S_API ISteamHTTP *SteamAPI_SteamGameServerHTTP_v003(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerHTTP(), but using this ensures that you are using a matching library. +inline ISteamHTTP *SteamAPI_SteamGameServerHTTP() { return SteamAPI_SteamGameServerHTTP_v003(); } +S_API HTTPRequestHandle SteamAPI_ISteamHTTP_CreateHTTPRequest( ISteamHTTP* self, EHTTPMethod eHTTPRequestMethod, const char * pchAbsoluteURL ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestContextValue( ISteamHTTP* self, HTTPRequestHandle hRequest, uint64 ulContextValue ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout( ISteamHTTP* self, HTTPRequestHandle hRequest, uint32 unTimeoutSeconds ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchHeaderName, const char * pchHeaderValue ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchParamName, const char * pchParamValue ); +S_API bool SteamAPI_ISteamHTTP_SendHTTPRequest( ISteamHTTP* self, HTTPRequestHandle hRequest, SteamAPICall_t * pCallHandle ); +S_API bool SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse( ISteamHTTP* self, HTTPRequestHandle hRequest, SteamAPICall_t * pCallHandle ); +S_API bool SteamAPI_ISteamHTTP_DeferHTTPRequest( ISteamHTTP* self, HTTPRequestHandle hRequest ); +S_API bool SteamAPI_ISteamHTTP_PrioritizeHTTPRequest( ISteamHTTP* self, HTTPRequestHandle hRequest ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchHeaderName, uint32 * unResponseHeaderSize ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchHeaderName, uint8 * pHeaderValueBuffer, uint32 unBufferSize ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPResponseBodySize( ISteamHTTP* self, HTTPRequestHandle hRequest, uint32 * unBodySize ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPResponseBodyData( ISteamHTTP* self, HTTPRequestHandle hRequest, uint8 * pBodyDataBuffer, uint32 unBufferSize ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData( ISteamHTTP* self, HTTPRequestHandle hRequest, uint32 cOffset, uint8 * pBodyDataBuffer, uint32 unBufferSize ); +S_API bool SteamAPI_ISteamHTTP_ReleaseHTTPRequest( ISteamHTTP* self, HTTPRequestHandle hRequest ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct( ISteamHTTP* self, HTTPRequestHandle hRequest, float * pflPercentOut ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchContentType, uint8 * pubBody, uint32 unBodyLen ); +S_API HTTPCookieContainerHandle SteamAPI_ISteamHTTP_CreateCookieContainer( ISteamHTTP* self, bool bAllowResponsesToModify ); +S_API bool SteamAPI_ISteamHTTP_ReleaseCookieContainer( ISteamHTTP* self, HTTPCookieContainerHandle hCookieContainer ); +S_API bool SteamAPI_ISteamHTTP_SetCookie( ISteamHTTP* self, HTTPCookieContainerHandle hCookieContainer, const char * pchHost, const char * pchUrl, const char * pchCookie ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer( ISteamHTTP* self, HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo( ISteamHTTP* self, HTTPRequestHandle hRequest, const char * pchUserAgentInfo ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate( ISteamHTTP* self, HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate ); +S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS( ISteamHTTP* self, HTTPRequestHandle hRequest, uint32 unMilliseconds ); +S_API bool SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut( ISteamHTTP* self, HTTPRequestHandle hRequest, bool * pbWasTimedOut ); + +// ISteamInput + +// A versioned accessor is exported by the library +S_API ISteamInput *SteamAPI_SteamInput_v006(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamInput(), but using this ensures that you are using a matching library. +inline ISteamInput *SteamAPI_SteamInput() { return SteamAPI_SteamInput_v006(); } +S_API bool SteamAPI_ISteamInput_Init( ISteamInput* self, bool bExplicitlyCallRunFrame ); +S_API bool SteamAPI_ISteamInput_Shutdown( ISteamInput* self ); +S_API bool SteamAPI_ISteamInput_SetInputActionManifestFilePath( ISteamInput* self, const char * pchInputActionManifestAbsolutePath ); +S_API void SteamAPI_ISteamInput_RunFrame( ISteamInput* self, bool bReservedValue ); +S_API bool SteamAPI_ISteamInput_BWaitForData( ISteamInput* self, bool bWaitForever, uint32 unTimeout ); +S_API bool SteamAPI_ISteamInput_BNewDataAvailable( ISteamInput* self ); +S_API int SteamAPI_ISteamInput_GetConnectedControllers( ISteamInput* self, InputHandle_t * handlesOut ); +S_API void SteamAPI_ISteamInput_EnableDeviceCallbacks( ISteamInput* self ); +S_API void SteamAPI_ISteamInput_EnableActionEventCallbacks( ISteamInput* self, SteamInputActionEventCallbackPointer pCallback ); +S_API InputActionSetHandle_t SteamAPI_ISteamInput_GetActionSetHandle( ISteamInput* self, const char * pszActionSetName ); +S_API void SteamAPI_ISteamInput_ActivateActionSet( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle ); +S_API InputActionSetHandle_t SteamAPI_ISteamInput_GetCurrentActionSet( ISteamInput* self, InputHandle_t inputHandle ); +S_API void SteamAPI_ISteamInput_ActivateActionSetLayer( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ); +S_API void SteamAPI_ISteamInput_DeactivateActionSetLayer( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ); +S_API void SteamAPI_ISteamInput_DeactivateAllActionSetLayers( ISteamInput* self, InputHandle_t inputHandle ); +S_API int SteamAPI_ISteamInput_GetActiveActionSetLayers( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t * handlesOut ); +S_API InputDigitalActionHandle_t SteamAPI_ISteamInput_GetDigitalActionHandle( ISteamInput* self, const char * pszActionName ); +S_API InputDigitalActionData_t SteamAPI_ISteamInput_GetDigitalActionData( ISteamInput* self, InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle ); +S_API int SteamAPI_ISteamInput_GetDigitalActionOrigins( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, EInputActionOrigin * originsOut ); +S_API const char * SteamAPI_ISteamInput_GetStringForDigitalActionName( ISteamInput* self, InputDigitalActionHandle_t eActionHandle ); +S_API InputAnalogActionHandle_t SteamAPI_ISteamInput_GetAnalogActionHandle( ISteamInput* self, const char * pszActionName ); +S_API InputAnalogActionData_t SteamAPI_ISteamInput_GetAnalogActionData( ISteamInput* self, InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle ); +S_API int SteamAPI_ISteamInput_GetAnalogActionOrigins( ISteamInput* self, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, EInputActionOrigin * originsOut ); +S_API const char * SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin( ISteamInput* self, EInputActionOrigin eOrigin, ESteamInputGlyphSize eSize, uint32 unFlags ); +S_API const char * SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin( ISteamInput* self, EInputActionOrigin eOrigin, uint32 unFlags ); +S_API const char * SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy( ISteamInput* self, EInputActionOrigin eOrigin ); +S_API const char * SteamAPI_ISteamInput_GetStringForActionOrigin( ISteamInput* self, EInputActionOrigin eOrigin ); +S_API const char * SteamAPI_ISteamInput_GetStringForAnalogActionName( ISteamInput* self, InputAnalogActionHandle_t eActionHandle ); +S_API void SteamAPI_ISteamInput_StopAnalogActionMomentum( ISteamInput* self, InputHandle_t inputHandle, InputAnalogActionHandle_t eAction ); +S_API InputMotionData_t SteamAPI_ISteamInput_GetMotionData( ISteamInput* self, InputHandle_t inputHandle ); +S_API void SteamAPI_ISteamInput_TriggerVibration( ISteamInput* self, InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ); +S_API void SteamAPI_ISteamInput_TriggerVibrationExtended( ISteamInput* self, InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed, unsigned short usLeftTriggerSpeed, unsigned short usRightTriggerSpeed ); +S_API void SteamAPI_ISteamInput_TriggerSimpleHapticEvent( ISteamInput* self, InputHandle_t inputHandle, EControllerHapticLocation eHapticLocation, uint8 nIntensity, char nGainDB, uint8 nOtherIntensity, char nOtherGainDB ); +S_API void SteamAPI_ISteamInput_SetLEDColor( ISteamInput* self, InputHandle_t inputHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ); +S_API void SteamAPI_ISteamInput_Legacy_TriggerHapticPulse( ISteamInput* self, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ); +S_API void SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse( ISteamInput* self, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ); +S_API bool SteamAPI_ISteamInput_ShowBindingPanel( ISteamInput* self, InputHandle_t inputHandle ); +S_API ESteamInputType SteamAPI_ISteamInput_GetInputTypeForHandle( ISteamInput* self, InputHandle_t inputHandle ); +S_API InputHandle_t SteamAPI_ISteamInput_GetControllerForGamepadIndex( ISteamInput* self, int nIndex ); +S_API int SteamAPI_ISteamInput_GetGamepadIndexForController( ISteamInput* self, InputHandle_t ulinputHandle ); +S_API const char * SteamAPI_ISteamInput_GetStringForXboxOrigin( ISteamInput* self, EXboxOrigin eOrigin ); +S_API const char * SteamAPI_ISteamInput_GetGlyphForXboxOrigin( ISteamInput* self, EXboxOrigin eOrigin ); +S_API EInputActionOrigin SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin( ISteamInput* self, InputHandle_t inputHandle, EXboxOrigin eOrigin ); +S_API EInputActionOrigin SteamAPI_ISteamInput_TranslateActionOrigin( ISteamInput* self, ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin ); +S_API bool SteamAPI_ISteamInput_GetDeviceBindingRevision( ISteamInput* self, InputHandle_t inputHandle, int * pMajor, int * pMinor ); +S_API uint32 SteamAPI_ISteamInput_GetRemotePlaySessionID( ISteamInput* self, InputHandle_t inputHandle ); +S_API uint16 SteamAPI_ISteamInput_GetSessionInputConfigurationSettings( ISteamInput* self ); +S_API void SteamAPI_ISteamInput_SetDualSenseTriggerEffect( ISteamInput* self, InputHandle_t inputHandle, const ScePadTriggerEffectParam * pParam ); + +// ISteamController + +// A versioned accessor is exported by the library +S_API ISteamController *SteamAPI_SteamController_v008(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamController(), but using this ensures that you are using a matching library. +inline ISteamController *SteamAPI_SteamController() { return SteamAPI_SteamController_v008(); } +S_API bool SteamAPI_ISteamController_Init( ISteamController* self ); +S_API bool SteamAPI_ISteamController_Shutdown( ISteamController* self ); +S_API void SteamAPI_ISteamController_RunFrame( ISteamController* self ); +S_API int SteamAPI_ISteamController_GetConnectedControllers( ISteamController* self, ControllerHandle_t * handlesOut ); +S_API ControllerActionSetHandle_t SteamAPI_ISteamController_GetActionSetHandle( ISteamController* self, const char * pszActionSetName ); +S_API void SteamAPI_ISteamController_ActivateActionSet( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ); +S_API ControllerActionSetHandle_t SteamAPI_ISteamController_GetCurrentActionSet( ISteamController* self, ControllerHandle_t controllerHandle ); +S_API void SteamAPI_ISteamController_ActivateActionSetLayer( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ); +S_API void SteamAPI_ISteamController_DeactivateActionSetLayer( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ); +S_API void SteamAPI_ISteamController_DeactivateAllActionSetLayers( ISteamController* self, ControllerHandle_t controllerHandle ); +S_API int SteamAPI_ISteamController_GetActiveActionSetLayers( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t * handlesOut ); +S_API ControllerDigitalActionHandle_t SteamAPI_ISteamController_GetDigitalActionHandle( ISteamController* self, const char * pszActionName ); +S_API InputDigitalActionData_t SteamAPI_ISteamController_GetDigitalActionData( ISteamController* self, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ); +S_API int SteamAPI_ISteamController_GetDigitalActionOrigins( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin * originsOut ); +S_API ControllerAnalogActionHandle_t SteamAPI_ISteamController_GetAnalogActionHandle( ISteamController* self, const char * pszActionName ); +S_API InputAnalogActionData_t SteamAPI_ISteamController_GetAnalogActionData( ISteamController* self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ); +S_API int SteamAPI_ISteamController_GetAnalogActionOrigins( ISteamController* self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin * originsOut ); +S_API const char * SteamAPI_ISteamController_GetGlyphForActionOrigin( ISteamController* self, EControllerActionOrigin eOrigin ); +S_API const char * SteamAPI_ISteamController_GetStringForActionOrigin( ISteamController* self, EControllerActionOrigin eOrigin ); +S_API void SteamAPI_ISteamController_StopAnalogActionMomentum( ISteamController* self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ); +S_API InputMotionData_t SteamAPI_ISteamController_GetMotionData( ISteamController* self, ControllerHandle_t controllerHandle ); +S_API void SteamAPI_ISteamController_TriggerHapticPulse( ISteamController* self, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ); +S_API void SteamAPI_ISteamController_TriggerRepeatedHapticPulse( ISteamController* self, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ); +S_API void SteamAPI_ISteamController_TriggerVibration( ISteamController* self, ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ); +S_API void SteamAPI_ISteamController_SetLEDColor( ISteamController* self, ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ); +S_API bool SteamAPI_ISteamController_ShowBindingPanel( ISteamController* self, ControllerHandle_t controllerHandle ); +S_API ESteamInputType SteamAPI_ISteamController_GetInputTypeForHandle( ISteamController* self, ControllerHandle_t controllerHandle ); +S_API ControllerHandle_t SteamAPI_ISteamController_GetControllerForGamepadIndex( ISteamController* self, int nIndex ); +S_API int SteamAPI_ISteamController_GetGamepadIndexForController( ISteamController* self, ControllerHandle_t ulControllerHandle ); +S_API const char * SteamAPI_ISteamController_GetStringForXboxOrigin( ISteamController* self, EXboxOrigin eOrigin ); +S_API const char * SteamAPI_ISteamController_GetGlyphForXboxOrigin( ISteamController* self, EXboxOrigin eOrigin ); +S_API EControllerActionOrigin SteamAPI_ISteamController_GetActionOriginFromXboxOrigin( ISteamController* self, ControllerHandle_t controllerHandle, EXboxOrigin eOrigin ); +S_API EControllerActionOrigin SteamAPI_ISteamController_TranslateActionOrigin( ISteamController* self, ESteamInputType eDestinationInputType, EControllerActionOrigin eSourceOrigin ); +S_API bool SteamAPI_ISteamController_GetControllerBindingRevision( ISteamController* self, ControllerHandle_t controllerHandle, int * pMajor, int * pMinor ); + +// ISteamUGC + +// A versioned accessor is exported by the library +S_API ISteamUGC *SteamAPI_SteamUGC_v020(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamUGC(), but using this ensures that you are using a matching library. +inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v020(); } + +// A versioned accessor is exported by the library +S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v020(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerUGC(), but using this ensures that you are using a matching library. +inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v020(); } +S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ); +S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ); +S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor ); +S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_SendQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCResult( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t * pDetails ); +S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCPreviewURL( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCMetadata( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, char * pchMetadata, uint32 cchMetadatasize ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCChildren( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCStatistic( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 * pStatValue ); +S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, char * pchURLOrVideoID, uint32 cchURLSize, char * pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType * pPreviewType ); +S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index ); +S_API bool SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize ); +S_API bool SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize ); +S_API uint32 SteamAPI_ISteamUGC_GetNumSupportedGameVersions( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index ); +S_API bool SteamAPI_ISteamUGC_GetSupportedGameVersionData( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 versionIndex, char * pchGameBranchMin, char * pchGameBranchMax, uint32 cchGameBranchSize ); +S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries ); +S_API bool SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle ); +S_API bool SteamAPI_ISteamUGC_AddRequiredTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pTagName ); +S_API bool SteamAPI_ISteamUGC_AddRequiredTagGroup( ISteamUGC* self, UGCQueryHandle_t handle, const SteamParamStringArray_t * pTagGroups ); +S_API bool SteamAPI_ISteamUGC_AddExcludedTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pTagName ); +S_API bool SteamAPI_ISteamUGC_SetReturnOnlyIDs( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnOnlyIDs ); +S_API bool SteamAPI_ISteamUGC_SetReturnKeyValueTags( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnKeyValueTags ); +S_API bool SteamAPI_ISteamUGC_SetReturnLongDescription( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnLongDescription ); +S_API bool SteamAPI_ISteamUGC_SetReturnMetadata( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnMetadata ); +S_API bool SteamAPI_ISteamUGC_SetReturnChildren( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnChildren ); +S_API bool SteamAPI_ISteamUGC_SetReturnAdditionalPreviews( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ); +S_API bool SteamAPI_ISteamUGC_SetReturnTotalOnly( ISteamUGC* self, UGCQueryHandle_t handle, bool bReturnTotalOnly ); +S_API bool SteamAPI_ISteamUGC_SetReturnPlaytimeStats( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unDays ); +S_API bool SteamAPI_ISteamUGC_SetLanguage( ISteamUGC* self, UGCQueryHandle_t handle, const char * pchLanguage ); +S_API bool SteamAPI_ISteamUGC_SetAllowCachedResponse( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ); +S_API bool SteamAPI_ISteamUGC_SetAdminQuery( ISteamUGC* self, UGCUpdateHandle_t handle, bool bAdminQuery ); +S_API bool SteamAPI_ISteamUGC_SetCloudFileNameFilter( ISteamUGC* self, UGCQueryHandle_t handle, const char * pMatchCloudFileName ); +S_API bool SteamAPI_ISteamUGC_SetMatchAnyTag( ISteamUGC* self, UGCQueryHandle_t handle, bool bMatchAnyTag ); +S_API bool SteamAPI_ISteamUGC_SetSearchText( ISteamUGC* self, UGCQueryHandle_t handle, const char * pSearchText ); +S_API bool SteamAPI_ISteamUGC_SetRankedByTrendDays( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unDays ); +S_API bool SteamAPI_ISteamUGC_SetTimeCreatedDateRange( ISteamUGC* self, UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ); +S_API bool SteamAPI_ISteamUGC_SetTimeUpdatedDateRange( ISteamUGC* self, UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ); +S_API bool SteamAPI_ISteamUGC_AddRequiredKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pKey, const char * pValue ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_RequestUGCDetails( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_CreateItem( ISteamUGC* self, AppId_t nConsumerAppId, EWorkshopFileType eFileType ); +S_API UGCUpdateHandle_t SteamAPI_ISteamUGC_StartItemUpdate( ISteamUGC* self, AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ); +S_API bool SteamAPI_ISteamUGC_SetItemTitle( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchTitle ); +S_API bool SteamAPI_ISteamUGC_SetItemDescription( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchDescription ); +S_API bool SteamAPI_ISteamUGC_SetItemUpdateLanguage( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchLanguage ); +S_API bool SteamAPI_ISteamUGC_SetItemMetadata( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchMetaData ); +S_API bool SteamAPI_ISteamUGC_SetItemVisibility( ISteamUGC* self, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ); +S_API bool SteamAPI_ISteamUGC_SetItemTags( ISteamUGC* self, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags, bool bAllowAdminTags ); +S_API bool SteamAPI_ISteamUGC_SetItemContent( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszContentFolder ); +S_API bool SteamAPI_ISteamUGC_SetItemPreview( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszPreviewFile ); +S_API bool SteamAPI_ISteamUGC_SetAllowLegacyUpload( ISteamUGC* self, UGCUpdateHandle_t handle, bool bAllowLegacyUpload ); +S_API bool SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags( ISteamUGC* self, UGCUpdateHandle_t handle ); +S_API bool SteamAPI_ISteamUGC_RemoveItemKeyValueTags( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchKey ); +S_API bool SteamAPI_ISteamUGC_AddItemKeyValueTag( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchKey, const char * pchValue ); +S_API bool SteamAPI_ISteamUGC_AddItemPreviewFile( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszPreviewFile, EItemPreviewType type ); +S_API bool SteamAPI_ISteamUGC_AddItemPreviewVideo( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszVideoID ); +S_API bool SteamAPI_ISteamUGC_UpdateItemPreviewFile( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index, const char * pszPreviewFile ); +S_API bool SteamAPI_ISteamUGC_UpdateItemPreviewVideo( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index, const char * pszVideoID ); +S_API bool SteamAPI_ISteamUGC_RemoveItemPreview( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index ); +S_API bool SteamAPI_ISteamUGC_AddContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ); +S_API bool SteamAPI_ISteamUGC_RemoveContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ); +S_API bool SteamAPI_ISteamUGC_SetRequiredGameVersions( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszGameBranchMin, const char * pszGameBranchMax ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_SubmitItemUpdate( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchChangeNote ); +S_API EItemUpdateStatus SteamAPI_ISteamUGC_GetItemUpdateProgress( ISteamUGC* self, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_SetUserItemVote( ISteamUGC* self, PublishedFileId_t nPublishedFileID, bool bVoteUp ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_GetUserItemVote( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_AddItemToFavorites( ISteamUGC* self, AppId_t nAppId, PublishedFileId_t nPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_RemoveItemFromFavorites( ISteamUGC* self, AppId_t nAppId, PublishedFileId_t nPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_SubscribeItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_UnsubscribeItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API uint32 SteamAPI_ISteamUGC_GetNumSubscribedItems( ISteamUGC* self ); +S_API uint32 SteamAPI_ISteamUGC_GetSubscribedItems( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries ); +S_API uint32 SteamAPI_ISteamUGC_GetItemState( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API bool SteamAPI_ISteamUGC_GetItemInstallInfo( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp ); +S_API bool SteamAPI_ISteamUGC_GetItemDownloadInfo( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal ); +S_API bool SteamAPI_ISteamUGC_DownloadItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID, bool bHighPriority ); +S_API bool SteamAPI_ISteamUGC_BInitWorkshopForGameServer( ISteamUGC* self, DepotId_t unWorkshopDepotID, const char * pszFolder ); +S_API void SteamAPI_ISteamUGC_SuspendDownloads( ISteamUGC* self, bool bSuspend ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_StartPlaytimeTracking( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_StopPlaytimeTracking( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems( ISteamUGC* self ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_AddDependency( ISteamUGC* self, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_RemoveDependency( ISteamUGC* self, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_AddAppDependency( ISteamUGC* self, PublishedFileId_t nPublishedFileID, AppId_t nAppID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_RemoveAppDependency( ISteamUGC* self, PublishedFileId_t nPublishedFileID, AppId_t nAppID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_GetAppDependencies( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_DeleteItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID ); +S_API bool SteamAPI_ISteamUGC_ShowWorkshopEULA( ISteamUGC* self ); +S_API SteamAPICall_t SteamAPI_ISteamUGC_GetWorkshopEULAStatus( ISteamUGC* self ); +S_API uint32 SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences( ISteamUGC* self, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries ); + +// ISteamHTMLSurface + +// A versioned accessor is exported by the library +S_API ISteamHTMLSurface *SteamAPI_SteamHTMLSurface_v005(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamHTMLSurface(), but using this ensures that you are using a matching library. +inline ISteamHTMLSurface *SteamAPI_SteamHTMLSurface() { return SteamAPI_SteamHTMLSurface_v005(); } +S_API bool SteamAPI_ISteamHTMLSurface_Init( ISteamHTMLSurface* self ); +S_API bool SteamAPI_ISteamHTMLSurface_Shutdown( ISteamHTMLSurface* self ); +S_API SteamAPICall_t SteamAPI_ISteamHTMLSurface_CreateBrowser( ISteamHTMLSurface* self, const char * pchUserAgent, const char * pchUserCSS ); +S_API void SteamAPI_ISteamHTMLSurface_RemoveBrowser( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_LoadURL( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char * pchURL, const char * pchPostData ); +S_API void SteamAPI_ISteamHTMLSurface_SetSize( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight ); +S_API void SteamAPI_ISteamHTMLSurface_StopLoad( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_Reload( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_GoBack( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_GoForward( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_AddHeader( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char * pchKey, const char * pchValue ); +S_API void SteamAPI_ISteamHTMLSurface_ExecuteJavascript( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char * pchScript ); +S_API void SteamAPI_ISteamHTMLSurface_MouseUp( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton ); +S_API void SteamAPI_ISteamHTMLSurface_MouseDown( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton ); +S_API void SteamAPI_ISteamHTMLSurface_MouseDoubleClick( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton ); +S_API void SteamAPI_ISteamHTMLSurface_MouseMove( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, int x, int y ); +S_API void SteamAPI_ISteamHTMLSurface_MouseWheel( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, int32 nDelta ); +S_API void SteamAPI_ISteamHTMLSurface_KeyDown( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers, bool bIsSystemKey ); +S_API void SteamAPI_ISteamHTMLSurface_KeyUp( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers ); +S_API void SteamAPI_ISteamHTMLSurface_KeyChar( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers ); +S_API void SteamAPI_ISteamHTMLSurface_SetHorizontalScroll( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ); +S_API void SteamAPI_ISteamHTMLSurface_SetVerticalScroll( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ); +S_API void SteamAPI_ISteamHTMLSurface_SetKeyFocus( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus ); +S_API void SteamAPI_ISteamHTMLSurface_ViewSource( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_CopyToClipboard( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_PasteFromClipboard( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_Find( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char * pchSearchStr, bool bCurrentlyInFind, bool bReverse ); +S_API void SteamAPI_ISteamHTMLSurface_StopFind( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_GetLinkAtPosition( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, int x, int y ); +S_API void SteamAPI_ISteamHTMLSurface_SetCookie( ISteamHTMLSurface* self, const char * pchHostname, const char * pchKey, const char * pchValue, const char * pchPath, RTime32 nExpires, bool bSecure, bool bHTTPOnly ); +S_API void SteamAPI_ISteamHTMLSurface_SetPageScaleFactor( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY ); +S_API void SteamAPI_ISteamHTMLSurface_SetBackgroundMode( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, bool bBackgroundMode ); +S_API void SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, float flDPIScaling ); +S_API void SteamAPI_ISteamHTMLSurface_OpenDeveloperTools( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle ); +S_API void SteamAPI_ISteamHTMLSurface_AllowStartRequest( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, bool bAllowed ); +S_API void SteamAPI_ISteamHTMLSurface_JSDialogResponse( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, bool bResult ); +S_API void SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char ** pchSelectedFiles ); + +// ISteamInventory + +// A versioned accessor is exported by the library +S_API ISteamInventory *SteamAPI_SteamInventory_v003(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamInventory(), but using this ensures that you are using a matching library. +inline ISteamInventory *SteamAPI_SteamInventory() { return SteamAPI_SteamInventory_v003(); } + +// A versioned accessor is exported by the library +S_API ISteamInventory *SteamAPI_SteamGameServerInventory_v003(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerInventory(), but using this ensures that you are using a matching library. +inline ISteamInventory *SteamAPI_SteamGameServerInventory() { return SteamAPI_SteamGameServerInventory_v003(); } +S_API EResult SteamAPI_ISteamInventory_GetResultStatus( ISteamInventory* self, SteamInventoryResult_t resultHandle ); +S_API bool SteamAPI_ISteamInventory_GetResultItems( ISteamInventory* self, SteamInventoryResult_t resultHandle, SteamItemDetails_t * pOutItemsArray, uint32 * punOutItemsArraySize ); +S_API bool SteamAPI_ISteamInventory_GetResultItemProperty( ISteamInventory* self, SteamInventoryResult_t resultHandle, uint32 unItemIndex, const char * pchPropertyName, char * pchValueBuffer, uint32 * punValueBufferSizeOut ); +S_API uint32 SteamAPI_ISteamInventory_GetResultTimestamp( ISteamInventory* self, SteamInventoryResult_t resultHandle ); +S_API bool SteamAPI_ISteamInventory_CheckResultSteamID( ISteamInventory* self, SteamInventoryResult_t resultHandle, uint64_steamid steamIDExpected ); +S_API void SteamAPI_ISteamInventory_DestroyResult( ISteamInventory* self, SteamInventoryResult_t resultHandle ); +S_API bool SteamAPI_ISteamInventory_GetAllItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle ); +S_API bool SteamAPI_ISteamInventory_GetItemsByID( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const SteamItemInstanceID_t * pInstanceIDs, uint32 unCountInstanceIDs ); +S_API bool SteamAPI_ISteamInventory_SerializeResult( ISteamInventory* self, SteamInventoryResult_t resultHandle, void * pOutBuffer, uint32 * punOutBufferSize ); +S_API bool SteamAPI_ISteamInventory_DeserializeResult( ISteamInventory* self, SteamInventoryResult_t * pOutResultHandle, const void * pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE ); +S_API bool SteamAPI_ISteamInventory_GenerateItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const SteamItemDef_t * pArrayItemDefs, const uint32 * punArrayQuantity, uint32 unArrayLength ); +S_API bool SteamAPI_ISteamInventory_GrantPromoItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle ); +S_API bool SteamAPI_ISteamInventory_AddPromoItem( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, SteamItemDef_t itemDef ); +S_API bool SteamAPI_ISteamInventory_AddPromoItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const SteamItemDef_t * pArrayItemDefs, uint32 unArrayLength ); +S_API bool SteamAPI_ISteamInventory_ConsumeItem( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity ); +S_API bool SteamAPI_ISteamInventory_ExchangeItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const SteamItemDef_t * pArrayGenerate, const uint32 * punArrayGenerateQuantity, uint32 unArrayGenerateLength, const SteamItemInstanceID_t * pArrayDestroy, const uint32 * punArrayDestroyQuantity, uint32 unArrayDestroyLength ); +S_API bool SteamAPI_ISteamInventory_TransferItemQuantity( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest ); +S_API void SteamAPI_ISteamInventory_SendItemDropHeartbeat( ISteamInventory* self ); +S_API bool SteamAPI_ISteamInventory_TriggerItemDrop( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, SteamItemDef_t dropListDefinition ); +S_API bool SteamAPI_ISteamInventory_TradeItems( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, uint64_steamid steamIDTradePartner, const SteamItemInstanceID_t * pArrayGive, const uint32 * pArrayGiveQuantity, uint32 nArrayGiveLength, const SteamItemInstanceID_t * pArrayGet, const uint32 * pArrayGetQuantity, uint32 nArrayGetLength ); +S_API bool SteamAPI_ISteamInventory_LoadItemDefinitions( ISteamInventory* self ); +S_API bool SteamAPI_ISteamInventory_GetItemDefinitionIDs( ISteamInventory* self, SteamItemDef_t * pItemDefIDs, uint32 * punItemDefIDsArraySize ); +S_API bool SteamAPI_ISteamInventory_GetItemDefinitionProperty( ISteamInventory* self, SteamItemDef_t iDefinition, const char * pchPropertyName, char * pchValueBuffer, uint32 * punValueBufferSizeOut ); +S_API SteamAPICall_t SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs( ISteamInventory* self, uint64_steamid steamID ); +S_API bool SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs( ISteamInventory* self, uint64_steamid steamID, SteamItemDef_t * pItemDefIDs, uint32 * punItemDefIDsArraySize ); +S_API SteamAPICall_t SteamAPI_ISteamInventory_StartPurchase( ISteamInventory* self, const SteamItemDef_t * pArrayItemDefs, const uint32 * punArrayQuantity, uint32 unArrayLength ); +S_API SteamAPICall_t SteamAPI_ISteamInventory_RequestPrices( ISteamInventory* self ); +S_API uint32 SteamAPI_ISteamInventory_GetNumItemsWithPrices( ISteamInventory* self ); +S_API bool SteamAPI_ISteamInventory_GetItemsWithPrices( ISteamInventory* self, SteamItemDef_t * pArrayItemDefs, uint64 * pCurrentPrices, uint64 * pBasePrices, uint32 unArrayLength ); +S_API bool SteamAPI_ISteamInventory_GetItemPrice( ISteamInventory* self, SteamItemDef_t iDefinition, uint64 * pCurrentPrice, uint64 * pBasePrice ); +S_API SteamInventoryUpdateHandle_t SteamAPI_ISteamInventory_StartUpdateProperties( ISteamInventory* self ); +S_API bool SteamAPI_ISteamInventory_RemoveProperty( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char * pchPropertyName ); +S_API bool SteamAPI_ISteamInventory_SetPropertyString( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char * pchPropertyName, const char * pchPropertyValue ); +S_API bool SteamAPI_ISteamInventory_SetPropertyBool( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char * pchPropertyName, bool bValue ); +S_API bool SteamAPI_ISteamInventory_SetPropertyInt64( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char * pchPropertyName, int64 nValue ); +S_API bool SteamAPI_ISteamInventory_SetPropertyFloat( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char * pchPropertyName, float flValue ); +S_API bool SteamAPI_ISteamInventory_SubmitUpdateProperties( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle ); +S_API bool SteamAPI_ISteamInventory_InspectItem( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const char * pchItemToken ); + +// ISteamTimeline + +// A versioned accessor is exported by the library +S_API ISteamTimeline *SteamAPI_SteamTimeline_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamTimeline(), but using this ensures that you are using a matching library. +inline ISteamTimeline *SteamAPI_SteamTimeline() { return SteamAPI_SteamTimeline_v001(); } +S_API void SteamAPI_ISteamTimeline_SetTimelineStateDescription( ISteamTimeline* self, const char * pchDescription, float flTimeDelta ); +S_API void SteamAPI_ISteamTimeline_ClearTimelineStateDescription( ISteamTimeline* self, float flTimeDelta ); +S_API void SteamAPI_ISteamTimeline_AddTimelineEvent( ISteamTimeline* self, const char * pchIcon, const char * pchTitle, const char * pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip ); +S_API void SteamAPI_ISteamTimeline_SetTimelineGameMode( ISteamTimeline* self, ETimelineGameMode eMode ); + +// ISteamVideo + +// A versioned accessor is exported by the library +S_API ISteamVideo *SteamAPI_SteamVideo_v007(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamVideo(), but using this ensures that you are using a matching library. +inline ISteamVideo *SteamAPI_SteamVideo() { return SteamAPI_SteamVideo_v007(); } +S_API void SteamAPI_ISteamVideo_GetVideoURL( ISteamVideo* self, AppId_t unVideoAppID ); +S_API bool SteamAPI_ISteamVideo_IsBroadcasting( ISteamVideo* self, int * pnNumViewers ); +S_API void SteamAPI_ISteamVideo_GetOPFSettings( ISteamVideo* self, AppId_t unVideoAppID ); +S_API bool SteamAPI_ISteamVideo_GetOPFStringForApp( ISteamVideo* self, AppId_t unVideoAppID, char * pchBuffer, int32 * pnBufferSize ); + +// ISteamParentalSettings + +// A versioned accessor is exported by the library +S_API ISteamParentalSettings *SteamAPI_SteamParentalSettings_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamParentalSettings(), but using this ensures that you are using a matching library. +inline ISteamParentalSettings *SteamAPI_SteamParentalSettings() { return SteamAPI_SteamParentalSettings_v001(); } +S_API bool SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled( ISteamParentalSettings* self ); +S_API bool SteamAPI_ISteamParentalSettings_BIsParentalLockLocked( ISteamParentalSettings* self ); +S_API bool SteamAPI_ISteamParentalSettings_BIsAppBlocked( ISteamParentalSettings* self, AppId_t nAppID ); +S_API bool SteamAPI_ISteamParentalSettings_BIsAppInBlockList( ISteamParentalSettings* self, AppId_t nAppID ); +S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureBlocked( ISteamParentalSettings* self, EParentalFeature eFeature ); +S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList( ISteamParentalSettings* self, EParentalFeature eFeature ); + +// ISteamRemotePlay + +// A versioned accessor is exported by the library +S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v002(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamRemotePlay(), but using this ensures that you are using a matching library. +inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v002(); } +S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionCount( ISteamRemotePlay* self ); +S_API RemotePlaySessionID_t SteamAPI_ISteamRemotePlay_GetSessionID( ISteamRemotePlay* self, int iSessionIndex ); +S_API uint64_steamid SteamAPI_ISteamRemotePlay_GetSessionSteamID( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID ); +S_API const char * SteamAPI_ISteamRemotePlay_GetSessionClientName( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID ); +S_API ESteamDeviceFormFactor SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID ); +S_API bool SteamAPI_ISteamRemotePlay_BGetSessionClientResolution( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, int * pnResolutionX, int * pnResolutionY ); +S_API bool SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether( ISteamRemotePlay* self, bool bShowOverlay ); +S_API bool SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite( ISteamRemotePlay* self, uint64_steamid steamIDFriend ); + +// ISteamNetworkingMessages + +// A versioned accessor is exported by the library +S_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI_v002(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingMessages_SteamAPI(), but using this ensures that you are using a matching library. +inline ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI() { return SteamAPI_SteamNetworkingMessages_SteamAPI_v002(); } + +// A versioned accessor is exported by the library +S_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworkingMessages_SteamAPI(), but using this ensures that you are using a matching library. +inline ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI() { return SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002(); } +S_API EResult SteamAPI_ISteamNetworkingMessages_SendMessageToUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, const void * pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ); +S_API int SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel( ISteamNetworkingMessages* self, int nLocalChannel, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages ); +S_API bool SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote ); +S_API bool SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote ); +S_API bool SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, int nLocalChannel ); +S_API ESteamNetworkingConnectionState SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, SteamNetConnectionInfo_t * pConnectionInfo, SteamNetConnectionRealTimeStatus_t * pQuickStatus ); + +// ISteamNetworkingSockets + +// A versioned accessor is exported by the library +S_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v012(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingSockets_SteamAPI(), but using this ensures that you are using a matching library. +inline ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI() { return SteamAPI_SteamNetworkingSockets_SteamAPI_v012(); } + +// A versioned accessor is exported by the library +S_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworkingSockets_SteamAPI(), but using this ensures that you are using a matching library. +inline ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI() { return SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012(); } +S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP( ISteamNetworkingSockets* self, const SteamNetworkingIPAddr & localAddress, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress( ISteamNetworkingSockets* self, const SteamNetworkingIPAddr & address, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P( ISteamNetworkingSockets* self, int nLocalVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectP2P( ISteamNetworkingSockets* self, const SteamNetworkingIdentity & identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API EResult SteamAPI_ISteamNetworkingSockets_AcceptConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn ); +S_API bool SteamAPI_ISteamNetworkingSockets_CloseConnection( ISteamNetworkingSockets* self, HSteamNetConnection hPeer, int nReason, const char * pszDebug, bool bEnableLinger ); +S_API bool SteamAPI_ISteamNetworkingSockets_CloseListenSocket( ISteamNetworkingSockets* self, HSteamListenSocket hSocket ); +S_API bool SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( ISteamNetworkingSockets* self, HSteamNetConnection hPeer, int64 nUserData ); +S_API int64 SteamAPI_ISteamNetworkingSockets_GetConnectionUserData( ISteamNetworkingSockets* self, HSteamNetConnection hPeer ); +S_API void SteamAPI_ISteamNetworkingSockets_SetConnectionName( ISteamNetworkingSockets* self, HSteamNetConnection hPeer, const char * pszName ); +S_API bool SteamAPI_ISteamNetworkingSockets_GetConnectionName( ISteamNetworkingSockets* self, HSteamNetConnection hPeer, char * pszName, int nMaxLen ); +S_API EResult SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn, const void * pData, uint32 cbData, int nSendFlags, int64 * pOutMessageNumber ); +S_API void SteamAPI_ISteamNetworkingSockets_SendMessages( ISteamNetworkingSockets* self, int nMessages, SteamNetworkingMessage_t *const * pMessages, int64 * pOutMessageNumberOrResult ); +S_API EResult SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn ); +S_API int SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages ); +S_API bool SteamAPI_ISteamNetworkingSockets_GetConnectionInfo( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetConnectionInfo_t * pInfo ); +S_API EResult SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t * pStatus, int nLanes, SteamNetConnectionRealTimeLaneStatus_t * pLanes ); +S_API int SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus( ISteamNetworkingSockets* self, HSteamNetConnection hConn, char * pszBuf, int cbBuf ); +S_API bool SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress( ISteamNetworkingSockets* self, HSteamListenSocket hSocket, SteamNetworkingIPAddr * address ); +S_API bool SteamAPI_ISteamNetworkingSockets_CreateSocketPair( ISteamNetworkingSockets* self, HSteamNetConnection * pOutConnection1, HSteamNetConnection * pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity * pIdentity1, const SteamNetworkingIdentity * pIdentity2 ); +S_API EResult SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes( ISteamNetworkingSockets* self, HSteamNetConnection hConn, int nNumLanes, const int * pLanePriorities, const uint16 * pLaneWeights ); +S_API bool SteamAPI_ISteamNetworkingSockets_GetIdentity( ISteamNetworkingSockets* self, SteamNetworkingIdentity * pIdentity ); +S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingSockets_InitAuthentication( ISteamNetworkingSockets* self ); +S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus( ISteamNetworkingSockets* self, SteamNetAuthenticationStatus_t * pDetails ); +S_API HSteamNetPollGroup SteamAPI_ISteamNetworkingSockets_CreatePollGroup( ISteamNetworkingSockets* self ); +S_API bool SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( ISteamNetworkingSockets* self, HSteamNetPollGroup hPollGroup ); +S_API bool SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup( ISteamNetworkingSockets* self, HSteamNetConnection hConn, HSteamNetPollGroup hPollGroup ); +S_API int SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup( ISteamNetworkingSockets* self, HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages ); +S_API bool SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket( ISteamNetworkingSockets* self, const void * pvTicket, int cbTicket, SteamDatagramRelayAuthTicket * pOutParsedTicket ); +S_API int SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer( ISteamNetworkingSockets* self, const SteamNetworkingIdentity & identityGameServer, int nRemoteVirtualPort, SteamDatagramRelayAuthTicket * pOutParsedTicket ); +S_API HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer( ISteamNetworkingSockets* self, const SteamNetworkingIdentity & identityTarget, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API uint16 SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort( ISteamNetworkingSockets* self ); +S_API SteamNetworkingPOPID SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID( ISteamNetworkingSockets* self ); +S_API EResult SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress( ISteamNetworkingSockets* self, SteamDatagramHostedAddress * pRouting ); +S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket( ISteamNetworkingSockets* self, int nLocalVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API EResult SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin( ISteamNetworkingSockets* self, SteamDatagramGameCoordinatorServerLogin * pLoginInfo, int * pcbSignedBlob, void * pBlob ); +S_API HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling( ISteamNetworkingSockets* self, ISteamNetworkingConnectionSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API bool SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal( ISteamNetworkingSockets* self, const void * pMsg, int cbMsg, ISteamNetworkingSignalingRecvContext * pContext ); +S_API bool SteamAPI_ISteamNetworkingSockets_GetCertificateRequest( ISteamNetworkingSockets* self, int * pcbBlob, void * pBlob, SteamNetworkingErrMsg & errMsg ); +S_API bool SteamAPI_ISteamNetworkingSockets_SetCertificate( ISteamNetworkingSockets* self, const void * pCertificate, int cbCertificate, SteamNetworkingErrMsg & errMsg ); +S_API void SteamAPI_ISteamNetworkingSockets_ResetIdentity( ISteamNetworkingSockets* self, const SteamNetworkingIdentity * pIdentity ); +S_API void SteamAPI_ISteamNetworkingSockets_RunCallbacks( ISteamNetworkingSockets* self ); +S_API bool SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP( ISteamNetworkingSockets* self, int nNumPorts ); +S_API void SteamAPI_ISteamNetworkingSockets_GetFakeIP( ISteamNetworkingSockets* self, int idxFirstPort, SteamNetworkingFakeIPResult_t * pInfo ); +S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP( ISteamNetworkingSockets* self, int idxFakePort, int nOptions, const SteamNetworkingConfigValue_t * pOptions ); +S_API EResult SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetworkingIPAddr * pOutAddr ); +S_API ISteamNetworkingFakeUDPPort * SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort( ISteamNetworkingSockets* self, int idxFakeServerPort ); + +// ISteamNetworkingUtils + +// A versioned accessor is exported by the library +S_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI_v004(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingUtils_SteamAPI(), but using this ensures that you are using a matching library. +inline ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI() { return SteamAPI_SteamNetworkingUtils_SteamAPI_v004(); } +S_API SteamNetworkingMessage_t * SteamAPI_ISteamNetworkingUtils_AllocateMessage( ISteamNetworkingUtils* self, int cbAllocateBuffer ); +S_API void SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess( ISteamNetworkingUtils* self ); +S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus( ISteamNetworkingUtils* self, SteamRelayNetworkStatus_t * pDetails ); +S_API float SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation( ISteamNetworkingUtils* self, SteamNetworkPingLocation_t & result ); +S_API int SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations( ISteamNetworkingUtils* self, const SteamNetworkPingLocation_t & location1, const SteamNetworkPingLocation_t & location2 ); +S_API int SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost( ISteamNetworkingUtils* self, const SteamNetworkPingLocation_t & remoteLocation ); +S_API void SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString( ISteamNetworkingUtils* self, const SteamNetworkPingLocation_t & location, char * pszBuf, int cchBufSize ); +S_API bool SteamAPI_ISteamNetworkingUtils_ParsePingLocationString( ISteamNetworkingUtils* self, const char * pszString, SteamNetworkPingLocation_t & result ); +S_API bool SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate( ISteamNetworkingUtils* self, float flMaxAgeSeconds ); +S_API int SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter( ISteamNetworkingUtils* self, SteamNetworkingPOPID popID, SteamNetworkingPOPID * pViaRelayPoP ); +S_API int SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP( ISteamNetworkingUtils* self, SteamNetworkingPOPID popID ); +S_API int SteamAPI_ISteamNetworkingUtils_GetPOPCount( ISteamNetworkingUtils* self ); +S_API int SteamAPI_ISteamNetworkingUtils_GetPOPList( ISteamNetworkingUtils* self, SteamNetworkingPOPID * list, int nListSz ); +S_API SteamNetworkingMicroseconds SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp( ISteamNetworkingUtils* self ); +S_API void SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction( ISteamNetworkingUtils* self, ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ); +S_API bool SteamAPI_ISteamNetworkingUtils_IsFakeIPv4( ISteamNetworkingUtils* self, uint32 nIPv4 ); +S_API ESteamNetworkingFakeIPType SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType( ISteamNetworkingUtils* self, uint32 nIPv4 ); +S_API EResult SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & fakeIP, SteamNetworkingIdentity * pOutRealIdentity ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, int32 val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, float val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, const char * val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, void * val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32( ISteamNetworkingUtils* self, HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat( ISteamNetworkingUtils* self, HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString( ISteamNetworkingUtils* self, HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char * val ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged( ISteamNetworkingUtils* self, FnSteamNetConnectionStatusChanged fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged( ISteamNetworkingUtils* self, FnSteamNetAuthenticationStatusChanged fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged( ISteamNetworkingUtils* self, FnSteamRelayNetworkStatusChanged fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult( ISteamNetworkingUtils* self, FnSteamNetworkingFakeIPResult fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest( ISteamNetworkingUtils* self, FnSteamNetworkingMessagesSessionRequest fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed( ISteamNetworkingUtils* self, FnSteamNetworkingMessagesSessionFailed fnCallback ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetConfigValue( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType eDataType, const void * pArg ); +S_API bool SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct( ISteamNetworkingUtils* self, const SteamNetworkingConfigValue_t & opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj ); +S_API ESteamNetworkingGetConfigValueResult SteamAPI_ISteamNetworkingUtils_GetConfigValue( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType * pOutDataType, void * pResult, size_t * cbResult ); +S_API const char * SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigDataType * pOutDataType, ESteamNetworkingConfigScope * pOutScope ); +S_API ESteamNetworkingConfigValue SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eCurrent, bool bEnumerateDevVars ); +S_API void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & addr, char * buf, uint32 cbBuf, bool bWithPort ); +S_API bool SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString( ISteamNetworkingUtils* self, SteamNetworkingIPAddr * pAddr, const char * pszStr ); +S_API ESteamNetworkingFakeIPType SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & addr ); +S_API void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString( ISteamNetworkingUtils* self, const SteamNetworkingIdentity & identity, char * buf, uint32 cbBuf ); +S_API bool SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString( ISteamNetworkingUtils* self, SteamNetworkingIdentity * pIdentity, const char * pszStr ); + +// ISteamGameServer + +// A versioned accessor is exported by the library +S_API ISteamGameServer *SteamAPI_SteamGameServer_v015(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServer(), but using this ensures that you are using a matching library. +inline ISteamGameServer *SteamAPI_SteamGameServer() { return SteamAPI_SteamGameServer_v015(); } +S_API void SteamAPI_ISteamGameServer_SetProduct( ISteamGameServer* self, const char * pszProduct ); +S_API void SteamAPI_ISteamGameServer_SetGameDescription( ISteamGameServer* self, const char * pszGameDescription ); +S_API void SteamAPI_ISteamGameServer_SetModDir( ISteamGameServer* self, const char * pszModDir ); +S_API void SteamAPI_ISteamGameServer_SetDedicatedServer( ISteamGameServer* self, bool bDedicated ); +S_API void SteamAPI_ISteamGameServer_LogOn( ISteamGameServer* self, const char * pszToken ); +S_API void SteamAPI_ISteamGameServer_LogOnAnonymous( ISteamGameServer* self ); +S_API void SteamAPI_ISteamGameServer_LogOff( ISteamGameServer* self ); +S_API bool SteamAPI_ISteamGameServer_BLoggedOn( ISteamGameServer* self ); +S_API bool SteamAPI_ISteamGameServer_BSecure( ISteamGameServer* self ); +S_API uint64_steamid SteamAPI_ISteamGameServer_GetSteamID( ISteamGameServer* self ); +S_API bool SteamAPI_ISteamGameServer_WasRestartRequested( ISteamGameServer* self ); +S_API void SteamAPI_ISteamGameServer_SetMaxPlayerCount( ISteamGameServer* self, int cPlayersMax ); +S_API void SteamAPI_ISteamGameServer_SetBotPlayerCount( ISteamGameServer* self, int cBotplayers ); +S_API void SteamAPI_ISteamGameServer_SetServerName( ISteamGameServer* self, const char * pszServerName ); +S_API void SteamAPI_ISteamGameServer_SetMapName( ISteamGameServer* self, const char * pszMapName ); +S_API void SteamAPI_ISteamGameServer_SetPasswordProtected( ISteamGameServer* self, bool bPasswordProtected ); +S_API void SteamAPI_ISteamGameServer_SetSpectatorPort( ISteamGameServer* self, uint16 unSpectatorPort ); +S_API void SteamAPI_ISteamGameServer_SetSpectatorServerName( ISteamGameServer* self, const char * pszSpectatorServerName ); +S_API void SteamAPI_ISteamGameServer_ClearAllKeyValues( ISteamGameServer* self ); +S_API void SteamAPI_ISteamGameServer_SetKeyValue( ISteamGameServer* self, const char * pKey, const char * pValue ); +S_API void SteamAPI_ISteamGameServer_SetGameTags( ISteamGameServer* self, const char * pchGameTags ); +S_API void SteamAPI_ISteamGameServer_SetGameData( ISteamGameServer* self, const char * pchGameData ); +S_API void SteamAPI_ISteamGameServer_SetRegion( ISteamGameServer* self, const char * pszRegion ); +S_API void SteamAPI_ISteamGameServer_SetAdvertiseServerActive( ISteamGameServer* self, bool bActive ); +S_API HAuthTicket SteamAPI_ISteamGameServer_GetAuthSessionTicket( ISteamGameServer* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSnid ); +S_API EBeginAuthSessionResult SteamAPI_ISteamGameServer_BeginAuthSession( ISteamGameServer* self, const void * pAuthTicket, int cbAuthTicket, uint64_steamid steamID ); +S_API void SteamAPI_ISteamGameServer_EndAuthSession( ISteamGameServer* self, uint64_steamid steamID ); +S_API void SteamAPI_ISteamGameServer_CancelAuthTicket( ISteamGameServer* self, HAuthTicket hAuthTicket ); +S_API EUserHasLicenseForAppResult SteamAPI_ISteamGameServer_UserHasLicenseForApp( ISteamGameServer* self, uint64_steamid steamID, AppId_t appID ); +S_API bool SteamAPI_ISteamGameServer_RequestUserGroupStatus( ISteamGameServer* self, uint64_steamid steamIDUser, uint64_steamid steamIDGroup ); +S_API void SteamAPI_ISteamGameServer_GetGameplayStats( ISteamGameServer* self ); +S_API SteamAPICall_t SteamAPI_ISteamGameServer_GetServerReputation( ISteamGameServer* self ); +S_API SteamIPAddress_t SteamAPI_ISteamGameServer_GetPublicIP( ISteamGameServer* self ); +S_API bool SteamAPI_ISteamGameServer_HandleIncomingPacket( ISteamGameServer* self, const void * pData, int cbData, uint32 srcIP, uint16 srcPort ); +S_API int SteamAPI_ISteamGameServer_GetNextOutgoingPacket( ISteamGameServer* self, void * pOut, int cbMaxOut, uint32 * pNetAdr, uint16 * pPort ); +S_API SteamAPICall_t SteamAPI_ISteamGameServer_AssociateWithClan( ISteamGameServer* self, uint64_steamid steamIDClan ); +S_API SteamAPICall_t SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility( ISteamGameServer* self, uint64_steamid steamIDNewPlayer ); +S_API bool SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED( ISteamGameServer* self, uint32 unIPClient, const void * pvAuthBlob, uint32 cubAuthBlobSize, CSteamID * pSteamIDUser ); +S_API uint64_steamid SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection( ISteamGameServer* self ); +S_API void SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED( ISteamGameServer* self, uint64_steamid steamIDUser ); +S_API bool SteamAPI_ISteamGameServer_BUpdateUserData( ISteamGameServer* self, uint64_steamid steamIDUser, const char * pchPlayerName, uint32 uScore ); + +// ISteamGameServerStats + +// A versioned accessor is exported by the library +S_API ISteamGameServerStats *SteamAPI_SteamGameServerStats_v001(); +// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerStats(), but using this ensures that you are using a matching library. +inline ISteamGameServerStats *SteamAPI_SteamGameServerStats() { return SteamAPI_SteamGameServerStats_v001(); } +S_API SteamAPICall_t SteamAPI_ISteamGameServerStats_RequestUserStats( ISteamGameServerStats* self, uint64_steamid steamIDUser ); +S_API bool SteamAPI_ISteamGameServerStats_GetUserStatInt32( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, int32 * pData ); +S_API bool SteamAPI_ISteamGameServerStats_GetUserStatFloat( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, float * pData ); +S_API bool SteamAPI_ISteamGameServerStats_GetUserAchievement( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, bool * pbAchieved ); +S_API bool SteamAPI_ISteamGameServerStats_SetUserStatInt32( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, int32 nData ); +S_API bool SteamAPI_ISteamGameServerStats_SetUserStatFloat( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, float fData ); +S_API bool SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, float flCountThisSession, double dSessionLength ); +S_API bool SteamAPI_ISteamGameServerStats_SetUserAchievement( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName ); +S_API bool SteamAPI_ISteamGameServerStats_ClearUserAchievement( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName ); +S_API SteamAPICall_t SteamAPI_ISteamGameServerStats_StoreUserStats( ISteamGameServerStats* self, uint64_steamid steamIDUser ); + +// ISteamNetworkingFakeUDPPort +S_API void SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort( ISteamNetworkingFakeUDPPort* self ); +S_API EResult SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP( ISteamNetworkingFakeUDPPort* self, const SteamNetworkingIPAddr & remoteAddress, const void * pData, uint32 cbData, int nSendFlags ); +S_API int SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages( ISteamNetworkingFakeUDPPort* self, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages ); +S_API void SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup( ISteamNetworkingFakeUDPPort* self, const SteamNetworkingIPAddr & remoteAddress ); + +// SteamIPAddress_t +S_API bool SteamAPI_SteamIPAddress_t_IsSet( SteamIPAddress_t* self ); + +// MatchMakingKeyValuePair_t +S_API void SteamAPI_MatchMakingKeyValuePair_t_Construct( MatchMakingKeyValuePair_t* self ); + +// servernetadr_t +S_API void SteamAPI_servernetadr_t_Construct( servernetadr_t* self ); +S_API void SteamAPI_servernetadr_t_Init( servernetadr_t* self, unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort ); +S_API uint16 SteamAPI_servernetadr_t_GetQueryPort( servernetadr_t* self ); +S_API void SteamAPI_servernetadr_t_SetQueryPort( servernetadr_t* self, uint16 usPort ); +S_API uint16 SteamAPI_servernetadr_t_GetConnectionPort( servernetadr_t* self ); +S_API void SteamAPI_servernetadr_t_SetConnectionPort( servernetadr_t* self, uint16 usPort ); +S_API uint32 SteamAPI_servernetadr_t_GetIP( servernetadr_t* self ); +S_API void SteamAPI_servernetadr_t_SetIP( servernetadr_t* self, uint32 unIP ); +S_API const char * SteamAPI_servernetadr_t_GetConnectionAddressString( servernetadr_t* self ); +S_API const char * SteamAPI_servernetadr_t_GetQueryAddressString( servernetadr_t* self ); +S_API bool SteamAPI_servernetadr_t_IsLessThan( servernetadr_t* self, const servernetadr_t & netadr ); +S_API void SteamAPI_servernetadr_t_Assign( servernetadr_t* self, const servernetadr_t & that ); + +// gameserveritem_t +S_API void SteamAPI_gameserveritem_t_Construct( gameserveritem_t* self ); +S_API const char * SteamAPI_gameserveritem_t_GetName( gameserveritem_t* self ); +S_API void SteamAPI_gameserveritem_t_SetName( gameserveritem_t* self, const char * pName ); + +// SteamNetworkingIPAddr +S_API void SteamAPI_SteamNetworkingIPAddr_Clear( SteamNetworkingIPAddr* self ); +S_API bool SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros( SteamNetworkingIPAddr* self ); +S_API void SteamAPI_SteamNetworkingIPAddr_SetIPv6( SteamNetworkingIPAddr* self, const uint8 * ipv6, uint16 nPort ); +S_API void SteamAPI_SteamNetworkingIPAddr_SetIPv4( SteamNetworkingIPAddr* self, uint32 nIP, uint16 nPort ); +S_API bool SteamAPI_SteamNetworkingIPAddr_IsIPv4( SteamNetworkingIPAddr* self ); +S_API uint32 SteamAPI_SteamNetworkingIPAddr_GetIPv4( SteamNetworkingIPAddr* self ); +S_API void SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost( SteamNetworkingIPAddr* self, uint16 nPort ); +S_API bool SteamAPI_SteamNetworkingIPAddr_IsLocalHost( SteamNetworkingIPAddr* self ); +S_API void SteamAPI_SteamNetworkingIPAddr_ToString( SteamNetworkingIPAddr* self, char * buf, uint32 cbBuf, bool bWithPort ); +S_API bool SteamAPI_SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr* self, const char * pszStr ); +S_API bool SteamAPI_SteamNetworkingIPAddr_IsEqualTo( SteamNetworkingIPAddr* self, const SteamNetworkingIPAddr & x ); +S_API ESteamNetworkingFakeIPType SteamAPI_SteamNetworkingIPAddr_GetFakeIPType( SteamNetworkingIPAddr* self ); +S_API bool SteamAPI_SteamNetworkingIPAddr_IsFakeIP( SteamNetworkingIPAddr* self ); + +// SteamNetworkingIdentity +S_API void SteamAPI_SteamNetworkingIdentity_Clear( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_IsInvalid( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetSteamID( SteamNetworkingIdentity* self, uint64_steamid steamID ); +S_API uint64_steamid SteamAPI_SteamNetworkingIdentity_GetSteamID( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetSteamID64( SteamNetworkingIdentity* self, uint64 steamID ); +S_API uint64 SteamAPI_SteamNetworkingIdentity_GetSteamID64( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID( SteamNetworkingIdentity* self, const char * pszString ); +S_API const char * SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetPSNID( SteamNetworkingIdentity* self, uint64 id ); +S_API uint64 SteamAPI_SteamNetworkingIdentity_GetPSNID( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetStadiaID( SteamNetworkingIdentity* self, uint64 id ); +S_API uint64 SteamAPI_SteamNetworkingIdentity_GetStadiaID( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetIPAddr( SteamNetworkingIdentity* self, const SteamNetworkingIPAddr & addr ); +S_API const SteamNetworkingIPAddr * SteamAPI_SteamNetworkingIdentity_GetIPAddr( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetIPv4Addr( SteamNetworkingIdentity* self, uint32 nIPv4, uint16 nPort ); +S_API uint32 SteamAPI_SteamNetworkingIdentity_GetIPv4( SteamNetworkingIdentity* self ); +S_API ESteamNetworkingFakeIPType SteamAPI_SteamNetworkingIdentity_GetFakeIPType( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_IsFakeIP( SteamNetworkingIdentity* self ); +S_API void SteamAPI_SteamNetworkingIdentity_SetLocalHost( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_IsLocalHost( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_SetGenericString( SteamNetworkingIdentity* self, const char * pszString ); +S_API const char * SteamAPI_SteamNetworkingIdentity_GetGenericString( SteamNetworkingIdentity* self ); +S_API bool SteamAPI_SteamNetworkingIdentity_SetGenericBytes( SteamNetworkingIdentity* self, const void * data, uint32 cbLen ); +S_API const uint8 * SteamAPI_SteamNetworkingIdentity_GetGenericBytes( SteamNetworkingIdentity* self, int & cbLen ); +S_API bool SteamAPI_SteamNetworkingIdentity_IsEqualTo( SteamNetworkingIdentity* self, const SteamNetworkingIdentity & x ); +S_API void SteamAPI_SteamNetworkingIdentity_ToString( SteamNetworkingIdentity* self, char * buf, uint32 cbBuf ); +S_API bool SteamAPI_SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity* self, const char * pszStr ); + +// SteamNetworkingMessage_t +S_API void SteamAPI_SteamNetworkingMessage_t_Release( SteamNetworkingMessage_t* self ); + +// SteamNetworkingConfigValue_t +S_API void SteamAPI_SteamNetworkingConfigValue_t_SetInt32( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, int32_t data ); +S_API void SteamAPI_SteamNetworkingConfigValue_t_SetInt64( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, int64_t data ); +S_API void SteamAPI_SteamNetworkingConfigValue_t_SetFloat( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, float data ); +S_API void SteamAPI_SteamNetworkingConfigValue_t_SetPtr( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, void * data ); +S_API void SteamAPI_SteamNetworkingConfigValue_t_SetString( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, const char * data ); + +// SteamDatagramHostedAddress +S_API void SteamAPI_SteamDatagramHostedAddress_Clear( SteamDatagramHostedAddress* self ); +S_API SteamNetworkingPOPID SteamAPI_SteamDatagramHostedAddress_GetPopID( SteamDatagramHostedAddress* self ); +S_API void SteamAPI_SteamDatagramHostedAddress_SetDevAddress( SteamDatagramHostedAddress* self, uint32 nIP, uint16 nPort, SteamNetworkingPOPID popid ); +#endif // STEAMAPIFLAT_H diff --git a/lsteamclient/steamworks_sdk_160/steam_api_internal.h b/lsteamclient/steamworks_sdk_160/steam_api_internal.h new file mode 100644 index 0000000000..a1a9bed093 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steam_api_internal.h @@ -0,0 +1,338 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Internal implementation details of the steamworks SDK. +// +// You should be able to figure out how to use the SDK by reading +// steam_api_common.h, and should not need to understand anything in here. +// +//----------------------------------------------------------------------------- + +#ifdef STEAM_CALLBACK_BEGIN +#error "This file should only be included from steam_api_common.h" +#endif + +#include + +// Internal functions used to locate/create interfaces +S_API HSteamPipe S_CALLTYPE SteamAPI_GetHSteamPipe(); +S_API HSteamUser S_CALLTYPE SteamAPI_GetHSteamUser(); +S_API HSteamPipe S_CALLTYPE SteamGameServer_GetHSteamPipe(); +S_API HSteamUser S_CALLTYPE SteamGameServer_GetHSteamUser(); +S_API void *S_CALLTYPE SteamInternal_ContextInit( void *pContextInitData ); +S_API void *S_CALLTYPE SteamInternal_CreateInterface( const char *ver ); +S_API void *S_CALLTYPE SteamInternal_FindOrCreateUserInterface( HSteamUser hSteamUser, const char *pszVersion ); +S_API void *S_CALLTYPE SteamInternal_FindOrCreateGameServerInterface( HSteamUser hSteamUser, const char *pszVersion ); + +// Macro used to define a type-safe accessor that will always return the version +// of the interface of the *header file* you are compiling with! We also bounce +// through a safety function that checks for interfaces being created or destroyed. +// +// SteamInternal_ContextInit takes a base pointer for the equivalent of +// struct { void (*pFn)(void* pCtx); uintptr_t counter; void *ptr; } +// Do not change layout or add non-pointer aligned data! +#define STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, expr, kind, version ) \ + inline void S_CALLTYPE SteamInternal_Init_ ## name( type *p ) { *p = (type)( expr ); } \ + STEAM_CLANG_ATTR( "interface_accessor_kind:" kind ";interface_accessor_version:" version ";" ) \ + inline type name() { \ + static void* s_CallbackCounterAndContext[ 3 ] = { (void*)&SteamInternal_Init_ ## name, 0, 0 }; \ + return *(type*)SteamInternal_ContextInit( s_CallbackCounterAndContext ); \ + } + +#define STEAM_DEFINE_USER_INTERFACE_ACCESSOR( type, name, version ) \ + STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, SteamInternal_FindOrCreateUserInterface( SteamAPI_GetHSteamUser(), version ), "user", version ) +#define STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( type, name, version ) \ + STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, SteamInternal_FindOrCreateGameServerInterface( SteamGameServer_GetHSteamUser(), version ), "gameserver", version ) + +// +// Internal stuff used for the standard, higher-level callback mechanism +// + +// Internal functions used by the utility CCallback objects to receive callbacks +S_API void S_CALLTYPE SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback ); +S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback ); +// Internal functions used by the utility CCallResult objects to receive async call results +S_API void S_CALLTYPE SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall ); +S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall ); + +#define _STEAM_CALLBACK_OFFSETOF( type, member ) ( (size_t)( (char *)&( (type *)0 )->member ) ) +#define _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) +#define _STEAM_CALLBACK_HELPER( _1, _2, SELECTED, ... ) _STEAM_CALLBACK_##SELECTED +#define _STEAM_CALLBACK_SELECT( X, Y ) _STEAM_CALLBACK_HELPER X Y +#define _STEAM_CALLBACK_3( extra_code, thisclass, func, param ) \ + struct CCallbackInternal_ ## func : private CCallbackImpl< sizeof( param ) > { \ + CCallbackInternal_ ## func () { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \ + CCallbackInternal_ ## func ( const CCallbackInternal_ ## func & ) { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \ + CCallbackInternal_ ## func & operator=( const CCallbackInternal_ ## func & ) { return *this; } \ + private: virtual void Run( void *pvParam ) S_OVERRIDE { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \ + thisclass *pOuter = reinterpret_cast( reinterpret_cast(this) - _STEAM_CALLBACK_OFFSETOF( thisclass, m_steamcallback_ ## func ) ); \ + pOuter->func( reinterpret_cast( pvParam ) ); \ + } \ + } m_steamcallback_ ## func ; void func( param *pParam ) +#define _STEAM_CALLBACK_4( _, thisclass, func, param, var ) \ + CCallback< thisclass, param > var; void func( param *pParam ) +#define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \ + CCallback< thisclass, param, true > var; void func( param *pParam ) + +#ifndef API_GEN + +template< class T, class P > +inline CCallResult::CCallResult() +{ + m_hAPICall = k_uAPICallInvalid; + m_pObj = nullptr; + m_Func = nullptr; + m_iCallback = P::k_iCallback; +} + +template< class T, class P > +inline void CCallResult::Set( SteamAPICall_t hAPICall, T *p, func_t func ) +{ + if ( m_hAPICall ) + SteamAPI_UnregisterCallResult( this, m_hAPICall ); + + m_hAPICall = hAPICall; + m_pObj = p; + m_Func = func; + + if ( hAPICall ) + SteamAPI_RegisterCallResult( this, hAPICall ); +} + +template< class T, class P > +inline bool CCallResult::IsActive() const +{ + return (m_hAPICall != k_uAPICallInvalid); +} + +template< class T, class P > +inline void CCallResult::Cancel() +{ + if ( m_hAPICall != k_uAPICallInvalid ) + { + SteamAPI_UnregisterCallResult( this, m_hAPICall ); + m_hAPICall = k_uAPICallInvalid; + } +} + +template< class T, class P > +inline CCallResult::~CCallResult() +{ + Cancel(); +} + +template< class T, class P > +inline void CCallResult::Run( void *pvParam ) +{ + m_hAPICall = k_uAPICallInvalid; // caller unregisters for us + (m_pObj->*m_Func)((P *)pvParam, false); +} + +template< class T, class P > +inline void CCallResult::Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) +{ + if ( hSteamAPICall == m_hAPICall ) + { + m_hAPICall = k_uAPICallInvalid; // caller unregisters for us + (m_pObj->*m_Func)((P *)pvParam, bIOFailure); + } +} + +template< class T, class P, bool bGameserver > +inline CCallback< T, P, bGameserver >::CCallback( T *pObj, func_t func ) + : m_pObj( nullptr ), m_Func( nullptr ) +{ + if ( bGameserver ) + { + this->SetGameserverFlag(); + } + Register( pObj, func ); +} + +template< class T, class P, bool bGameserver > +inline void CCallback< T, P, bGameserver >::Register( T *pObj, func_t func ) +{ + if ( !pObj || !func ) + return; + + if ( this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered ) + Unregister(); + + m_pObj = pObj; + m_Func = func; + // SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered + SteamAPI_RegisterCallback( this, P::k_iCallback ); +} + +template< class T, class P, bool bGameserver > +inline void CCallback< T, P, bGameserver >::Unregister() +{ + // SteamAPI_UnregisterCallback removes k_ECallbackFlagsRegistered + SteamAPI_UnregisterCallback( this ); +} + +template< class T, class P, bool bGameserver > +inline void CCallback< T, P, bGameserver >::Run( void *pvParam ) +{ + (m_pObj->*m_Func)((P *)pvParam); +} + +#endif // #ifndef API_GEN + +// structure that contains client callback data +// see callbacks documentation for more details +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx +#endif + +/// Internal structure used in manual callback dispatch +struct CallbackMsg_t +{ + HSteamUser m_hSteamUser; // Specific user to whom this callback applies. + int m_iCallback; // Callback identifier. (Corresponds to the k_iCallback enum in the callback structure.) + uint8 *m_pubParam; // Points to the callback structure + int m_cubParam; // Size of the data pointed to by m_pubParam +}; +#pragma pack( pop ) + +// Macros to define steam callback structures. Used internally for debugging +#ifdef STEAM_CALLBACK_INSPECTION_ENABLED + #include "../../clientdll/steam_api_callback_inspection.h" +#else + #define STEAM_CALLBACK_BEGIN( callbackname, callbackid ) struct callbackname { enum { k_iCallback = callbackid }; + #define STEAM_CALLBACK_MEMBER( varidx, vartype, varname ) vartype varname ; + #define STEAM_CALLBACK_MEMBER_ARRAY( varidx, vartype, varname, varcount ) vartype varname [ varcount ]; + #define STEAM_CALLBACK_END(nArgs) }; +#endif + +// Forward declare all of the Steam interfaces. (Do we really need to do this?) +class ISteamClient; +class ISteamUser; +class ISteamGameServer; +class ISteamFriends; +class ISteamUtils; +class ISteamMatchmaking; +class ISteamContentServer; +class ISteamMatchmakingServers; +class ISteamUserStats; +class ISteamApps; +class ISteamNetworking; +class ISteamRemoteStorage; +class ISteamScreenshots; +class ISteamMusic; +class ISteamMusicRemote; +class ISteamGameServerStats; +class ISteamPS3OverlayRender; +class ISteamHTTP; +class ISteamController; +class ISteamUGC; +class ISteamHTMLSurface; +class ISteamInventory; +class ISteamVideo; +class ISteamParentalSettings; +class ISteamGameSearch; +class ISteamInput; +class ISteamParties; +class ISteamRemotePlay; + +// Forward declare types +struct SteamNetworkingIdentity; + +//----------------------------------------------------------------------------- +// Purpose: Base values for callback identifiers, each callback must +// have a unique ID. +//----------------------------------------------------------------------------- +enum { k_iSteamUserCallbacks = 100 }; +enum { k_iSteamGameServerCallbacks = 200 }; +enum { k_iSteamFriendsCallbacks = 300 }; +enum { k_iSteamBillingCallbacks = 400 }; +enum { k_iSteamMatchmakingCallbacks = 500 }; +enum { k_iSteamContentServerCallbacks = 600 }; +enum { k_iSteamUtilsCallbacks = 700 }; +enum { k_iSteamAppsCallbacks = 1000 }; +enum { k_iSteamUserStatsCallbacks = 1100 }; +enum { k_iSteamNetworkingCallbacks = 1200 }; +enum { k_iSteamNetworkingSocketsCallbacks = 1220 }; +enum { k_iSteamNetworkingMessagesCallbacks = 1250 }; +enum { k_iSteamNetworkingUtilsCallbacks = 1280 }; +enum { k_iSteamRemoteStorageCallbacks = 1300 }; +enum { k_iSteamGameServerItemsCallbacks = 1500 }; +enum { k_iSteamGameCoordinatorCallbacks = 1700 }; +enum { k_iSteamGameServerStatsCallbacks = 1800 }; +enum { k_iSteam2AsyncCallbacks = 1900 }; +enum { k_iSteamGameStatsCallbacks = 2000 }; +enum { k_iSteamHTTPCallbacks = 2100 }; +enum { k_iSteamScreenshotsCallbacks = 2300 }; +// NOTE: 2500-2599 are reserved +enum { k_iSteamStreamLauncherCallbacks = 2600 }; +enum { k_iSteamControllerCallbacks = 2800 }; +enum { k_iSteamUGCCallbacks = 3400 }; +enum { k_iSteamStreamClientCallbacks = 3500 }; +enum { k_iSteamMusicCallbacks = 4000 }; +enum { k_iSteamMusicRemoteCallbacks = 4100 }; +enum { k_iSteamGameNotificationCallbacks = 4400 }; +enum { k_iSteamHTMLSurfaceCallbacks = 4500 }; +enum { k_iSteamVideoCallbacks = 4600 }; +enum { k_iSteamInventoryCallbacks = 4700 }; +enum { k_ISteamParentalSettingsCallbacks = 5000 }; +enum { k_iSteamGameSearchCallbacks = 5200 }; +enum { k_iSteamPartiesCallbacks = 5300 }; +enum { k_iSteamSTARCallbacks = 5500 }; +enum { k_iSteamRemotePlayCallbacks = 5700 }; +enum { k_iSteamChatCallbacks = 5900 }; +enum { k_iSteamTimelineCallbacks = 6000 }; +// NOTE: Internal "IClientXxx" callback IDs go in clientenums.h + +// Macros used to annotate various Steamworks interfaces to generate the +// flat API +#ifdef API_GEN +# define STEAM_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR ))) +#else +# define STEAM_CLANG_ATTR(ATTR) +#endif + +#define STEAM_OUT_STRUCT() STEAM_CLANG_ATTR( "out_struct: ;" ) +#define STEAM_OUT_STRING() STEAM_CLANG_ATTR( "out_string: ;" ) +#define STEAM_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) STEAM_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" ) +#define STEAM_OUT_ARRAY_COUNT(COUNTER, DESC) STEAM_CLANG_ATTR( "out_array_count:" #COUNTER ";desc:" #DESC ) +#define STEAM_ARRAY_COUNT(COUNTER) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";" ) +#define STEAM_ARRAY_COUNT_D(COUNTER, DESC) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC ) +#define STEAM_BUFFER_COUNT(COUNTER) STEAM_CLANG_ATTR( "buffer_count:" #COUNTER ";" ) +#define STEAM_OUT_BUFFER_COUNT(COUNTER) STEAM_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" ) +#define STEAM_OUT_STRING_COUNT(COUNTER) STEAM_CLANG_ATTR( "out_string_count:" #COUNTER ";" ) +#define STEAM_DESC(DESC) STEAM_CLANG_ATTR("desc:" #DESC ";") +#define STEAM_CALL_RESULT(RESULT_TYPE) STEAM_CLANG_ATTR("callresult:" #RESULT_TYPE ";") +#define STEAM_CALL_BACK(RESULT_TYPE) STEAM_CLANG_ATTR("callback:" #RESULT_TYPE ";") +#define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";") + +class CSteamGameServerAPIContext +{ +public: + CSteamGameServerAPIContext() { Clear(); } + inline void Clear() { memset( this, 0, sizeof(*this) ); } + inline bool Init(); // NOTE: This is defined in steam_gameserver.h, to avoid this file having to include everything + + ISteamClient *SteamClient() const { return m_pSteamClient; } + ISteamGameServer *SteamGameServer() const { return m_pSteamGameServer; } + ISteamUtils *SteamGameServerUtils() const { return m_pSteamGameServerUtils; } + ISteamNetworking *SteamGameServerNetworking() const { return m_pSteamGameServerNetworking; } + ISteamGameServerStats *SteamGameServerStats() const { return m_pSteamGameServerStats; } + ISteamHTTP *SteamHTTP() const { return m_pSteamHTTP; } + ISteamInventory *SteamInventory() const { return m_pSteamInventory; } + ISteamUGC *SteamUGC() const { return m_pSteamUGC; } + +private: + ISteamClient *m_pSteamClient; + ISteamGameServer *m_pSteamGameServer; + ISteamUtils *m_pSteamGameServerUtils; + ISteamNetworking *m_pSteamGameServerNetworking; + ISteamGameServerStats *m_pSteamGameServerStats; + ISteamHTTP *m_pSteamHTTP; + ISteamInventory *m_pSteamInventory; + ISteamUGC *m_pSteamUGC; +}; + + diff --git a/lsteamclient/steamworks_sdk_160/steam_gameserver.h b/lsteamclient/steamworks_sdk_160/steam_gameserver.h new file mode 100644 index 0000000000..f3873db00d --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steam_gameserver.h @@ -0,0 +1,137 @@ +//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: +// +//============================================================================= + +#ifndef STEAM_GAMESERVER_H +#define STEAM_GAMESERVER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "steam_api.h" +#include "isteamgameserver.h" +#include "isteamgameserverstats.h" + +enum EServerMode +{ + eServerModeInvalid = 0, // DO NOT USE + eServerModeNoAuthentication = 1, // Don't authenticate user logins and don't list on the server list + eServerModeAuthentication = 2, // Authenticate users, list on the server list, don't run VAC on clients that connect + eServerModeAuthenticationAndSecure = 3, // Authenticate users, list on the server list and VAC protect clients +}; + +/// Pass to SteamGameServer_Init to indicate that the same UDP port will be used for game traffic +/// UDP queries for server browser pings and LAN discovery. In this case, Steam will not open up a +/// socket to handle server browser queries, and you must use ISteamGameServer::HandleIncomingPacket +/// and ISteamGameServer::GetNextOutgoingPacket to handle packets related to server discovery on your socket. +const uint16 STEAMGAMESERVER_QUERY_PORT_SHARED = 0xffff; + +// DEPRECATED: This old name was really confusing. +const uint16 MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE = STEAMGAMESERVER_QUERY_PORT_SHARED; + +// Initialize SteamGameServer client and interface objects, and set server properties which may not be changed. +// +// After calling this function, you should set any additional server parameters, and then +// call ISteamGameServer::LogOnAnonymous() or ISteamGameServer::LogOn() +// +// - unIP will usually be zero. If you are on a machine with multiple IP addresses, you can pass a non-zero +// value here and the relevant sockets will be bound to that IP. This can be used to ensure that +// the IP you desire is the one used in the server browser. +// - usGamePort is the port that clients will connect to for gameplay. You will usually open up your +// own socket bound to this port. +// - usQueryPort is the port that will manage server browser related duties and info +// pings from clients. If you pass STEAMGAMESERVER_QUERY_PORT_SHARED for usQueryPort, then it +// will use "GameSocketShare" mode, which means that the game is responsible for sending and receiving +// UDP packets for the master server updater. (See ISteamGameServer::HandleIncomingPacket and +// ISteamGameServer::GetNextOutgoingPacket.) +// - The version string should be in the form x.x.x.x, and is used by the master server to detect when the +// server is out of date. (Only servers with the latest version will be listed.) +// +// On success k_ESteamAPIInitResult_OK is returned. Otherwise, if pOutErrMsg is non-NULL, +// it will receive a non-localized message that explains the reason for the failure +inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg ); + +// This function is included for compatibility with older SDK. +// You can use it if you don't care about decent error handling +inline bool SteamGameServer_Init( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ) +{ + return SteamGameServer_InitEx( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, NULL ) == k_ESteamAPIInitResult_OK; +} + +// Shutdown SteamGameSeverXxx interfaces, log out, and free resources. +S_API void SteamGameServer_Shutdown(); + +// Most Steam API functions allocate some amount of thread-local memory for +// parameter storage. Calling SteamGameServer_ReleaseCurrentThreadMemory() +// will free all API-related memory associated with the calling thread. +// This memory is released automatically by SteamGameServer_RunCallbacks(), +// so single-threaded servers do not need to explicitly call this function. +inline void SteamGameServer_ReleaseCurrentThreadMemory(); + +S_API bool SteamGameServer_BSecure(); +S_API uint64 SteamGameServer_GetSteamID(); + +// Older SDKs exported this global pointer, but it is no longer supported. +// You should use SteamGameServerClient() or CSteamGameServerAPIContext to +// safely access the ISteamClient APIs from your game server application. +//S_API ISteamClient *g_pSteamClientGameServer; + +// SteamGameServer_InitSafe has been replaced with SteamGameServer_Init and +// is no longer supported. Use SteamGameServer_Init instead. +//S_API void S_CALLTYPE SteamGameServer_InitSafe(); + +//============================================================================= +// +// Internal implementation details below +// +//============================================================================= + +#ifndef STEAM_API_EXPORTS +// This function must be declared inline in the header so the module using steam_api.dll gets the version names they want. +inline bool CSteamGameServerAPIContext::Init() +{ + m_pSteamClient = ::SteamGameServerClient(); + if ( !m_pSteamClient ) + return false; + + m_pSteamGameServer = ::SteamGameServer(); + m_pSteamGameServerUtils = ::SteamGameServerUtils(); + m_pSteamGameServerNetworking = ::SteamGameServerNetworking(); + m_pSteamGameServerStats = ::SteamGameServerStats(); + m_pSteamHTTP = ::SteamGameServerHTTP(); + m_pSteamInventory = ::SteamGameServerInventory(); + m_pSteamUGC = ::SteamGameServerUGC(); + if ( !m_pSteamGameServer || !m_pSteamGameServerUtils || !m_pSteamGameServerNetworking || !m_pSteamGameServerStats + || !m_pSteamHTTP || !m_pSteamInventory || !m_pSteamUGC ) + return false; + + return true; +} +#endif + +S_API ESteamAPIInitResult S_CALLTYPE SteamInternal_GameServer_Init_V2( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, const char *pszInternalCheckInterfaceVersions, SteamErrMsg *pOutErrMsg ); +inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg ) +{ + const char *pszInternalCheckInterfaceVersions = + STEAMUTILS_INTERFACE_VERSION "\0" + STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0" + + STEAMGAMESERVER_INTERFACE_VERSION "\0" + STEAMGAMESERVERSTATS_INTERFACE_VERSION "\0" + STEAMHTTP_INTERFACE_VERSION "\0" + STEAMINVENTORY_INTERFACE_VERSION "\0" + STEAMNETWORKING_INTERFACE_VERSION "\0" + STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0" + STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0" + STEAMUGC_INTERFACE_VERSION "\0" + "\0"; + return SteamInternal_GameServer_Init_V2( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, pszInternalCheckInterfaceVersions, pOutErrMsg ); +} +inline void SteamGameServer_ReleaseCurrentThreadMemory() +{ + SteamAPI_ReleaseCurrentThreadMemory(); +} + +#endif // STEAM_GAMESERVER_H diff --git a/lsteamclient/steamworks_sdk_160/steamclientpublic.h b/lsteamclient/steamworks_sdk_160/steamclientpublic.h new file mode 100644 index 0000000000..2bd66253f3 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamclientpublic.h @@ -0,0 +1,1198 @@ +//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ +// +// Declare common types used by the Steamworks SDK. +// +//============================================================================= + +#ifndef STEAMCLIENTPUBLIC_H +#define STEAMCLIENTPUBLIC_H + +#include "steamtypes.h" +#include "steamuniverse.h" + +// General result codes +enum EResult +{ + k_EResultNone = 0, // no result + k_EResultOK = 1, // success + k_EResultFail = 2, // generic failure + k_EResultNoConnection = 3, // no/failed network connection +// k_EResultNoConnectionRetry = 4, // OBSOLETE - removed + k_EResultInvalidPassword = 5, // password/ticket is invalid + k_EResultLoggedInElsewhere = 6, // same user logged in elsewhere + k_EResultInvalidProtocolVer = 7, // protocol version is incorrect + k_EResultInvalidParam = 8, // a parameter is incorrect + k_EResultFileNotFound = 9, // file was not found + k_EResultBusy = 10, // called method busy - action not taken + k_EResultInvalidState = 11, // called object was in an invalid state + k_EResultInvalidName = 12, // name is invalid + k_EResultInvalidEmail = 13, // email is invalid + k_EResultDuplicateName = 14, // name is not unique + k_EResultAccessDenied = 15, // access is denied + k_EResultTimeout = 16, // operation timed out + k_EResultBanned = 17, // VAC2 banned + k_EResultAccountNotFound = 18, // account not found + k_EResultInvalidSteamID = 19, // steamID is invalid + k_EResultServiceUnavailable = 20, // The requested service is currently unavailable + k_EResultNotLoggedOn = 21, // The user is not logged on + k_EResultPending = 22, // Request is pending (may be in process, or waiting on third party) + k_EResultEncryptionFailure = 23, // Encryption or Decryption failed + k_EResultInsufficientPrivilege = 24, // Insufficient privilege + k_EResultLimitExceeded = 25, // Too much of a good thing + k_EResultRevoked = 26, // Access has been revoked (used for revoked guest passes) + k_EResultExpired = 27, // License/Guest pass the user is trying to access is expired + k_EResultAlreadyRedeemed = 28, // Guest pass has already been redeemed by account, cannot be acked again + k_EResultDuplicateRequest = 29, // The request is a duplicate and the action has already occurred in the past, ignored this time + k_EResultAlreadyOwned = 30, // All the games in this guest pass redemption request are already owned by the user + k_EResultIPNotFound = 31, // IP address not found + k_EResultPersistFailed = 32, // failed to write change to the data store + k_EResultLockingFailed = 33, // failed to acquire access lock for this operation + k_EResultLogonSessionReplaced = 34, + k_EResultConnectFailed = 35, + k_EResultHandshakeFailed = 36, + k_EResultIOFailure = 37, + k_EResultRemoteDisconnect = 38, + k_EResultShoppingCartNotFound = 39, // failed to find the shopping cart requested + k_EResultBlocked = 40, // a user didn't allow it + k_EResultIgnored = 41, // target is ignoring sender + k_EResultNoMatch = 42, // nothing matching the request found + k_EResultAccountDisabled = 43, + k_EResultServiceReadOnly = 44, // this service is not accepting content changes right now + k_EResultAccountNotFeatured = 45, // account doesn't have value, so this feature isn't available + k_EResultAdministratorOK = 46, // allowed to take this action, but only because requester is admin + k_EResultContentVersion = 47, // A Version mismatch in content transmitted within the Steam protocol. + k_EResultTryAnotherCM = 48, // The current CM can't service the user making a request, user should try another. + k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed. + k_EResultAlreadyLoggedInElsewhere = 50, // You are already logged in elsewhere, you must wait + k_EResultSuspended = 51, // Long running operation (content download) suspended/paused + k_EResultCancelled = 52, // Operation canceled (typically by user: content download) + k_EResultDataCorruption = 53, // Operation canceled because data is ill formed or unrecoverable + k_EResultDiskFull = 54, // Operation canceled - not enough disk space. + k_EResultRemoteCallFailed = 55, // an remote call or IPC call failed + k_EResultPasswordUnset = 56, // Password could not be verified as it's unset server side + k_EResultExternalAccountUnlinked = 57, // External account (PSN, Facebook...) is not linked to a Steam account + k_EResultPSNTicketInvalid = 58, // PSN ticket was invalid + k_EResultExternalAccountAlreadyLinked = 59, // External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first + k_EResultRemoteFileConflict = 60, // The sync cannot resume due to a conflict between the local and remote files + k_EResultIllegalPassword = 61, // The requested new password is not legal + k_EResultSameAsPreviousValue = 62, // new value is the same as the old one ( secret question and answer ) + k_EResultAccountLogonDenied = 63, // account login denied due to 2nd factor authentication failure + k_EResultCannotUseOldPassword = 64, // The requested new password is not legal + k_EResultInvalidLoginAuthCode = 65, // account login denied due to auth code invalid + k_EResultAccountLogonDeniedNoMail = 66, // account login denied due to 2nd factor auth failure - and no mail has been sent - partner site specific + k_EResultHardwareNotCapableOfIPT = 67, // + k_EResultIPTInitError = 68, // + k_EResultParentalControlRestricted = 69, // operation failed due to parental control restrictions for current user + k_EResultFacebookQueryError = 70, // Facebook query returned an error + k_EResultExpiredLoginAuthCode = 71, // account login denied due to auth code expired + k_EResultIPLoginRestrictionFailed = 72, + k_EResultAccountLockedDown = 73, + k_EResultAccountLogonDeniedVerifiedEmailRequired = 74, + k_EResultNoMatchingURL = 75, + k_EResultBadResponse = 76, // parse failure, missing field, etc. + k_EResultRequirePasswordReEntry = 77, // The user cannot complete the action until they re-enter their password + k_EResultValueOutOfRange = 78, // the value entered is outside the acceptable range + k_EResultUnexpectedError = 79, // something happened that we didn't expect to ever happen + k_EResultDisabled = 80, // The requested service has been configured to be unavailable + k_EResultInvalidCEGSubmission = 81, // The set of files submitted to the CEG server are not valid ! + k_EResultRestrictedDevice = 82, // The device being used is not allowed to perform this action + k_EResultRegionLocked = 83, // The action could not be complete because it is region restricted + k_EResultRateLimitExceeded = 84, // Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent + k_EResultAccountLoginDeniedNeedTwoFactor = 85, // Need two-factor code to login + k_EResultItemDeleted = 86, // The thing we're trying to access has been deleted + k_EResultAccountLoginDeniedThrottle = 87, // login attempt failed, try to throttle response to possible attacker + k_EResultTwoFactorCodeMismatch = 88, // two factor code mismatch + k_EResultTwoFactorActivationCodeMismatch = 89, // activation code for two-factor didn't match + k_EResultAccountAssociatedToMultiplePartners = 90, // account has been associated with multiple partners + k_EResultNotModified = 91, // data not modified + k_EResultNoMobileDevice = 92, // the account does not have a mobile device associated with it + k_EResultTimeNotSynced = 93, // the time presented is out of range or tolerance + k_EResultSmsCodeFailed = 94, // SMS code failure (no match, none pending, etc.) + k_EResultAccountLimitExceeded = 95, // Too many accounts access this resource + k_EResultAccountActivityLimitExceeded = 96, // Too many changes to this account + k_EResultPhoneActivityLimitExceeded = 97, // Too many changes to this phone + k_EResultRefundToWallet = 98, // Cannot refund to payment method, must use wallet + k_EResultEmailSendFailure = 99, // Cannot send an email + k_EResultNotSettled = 100, // Can't perform operation till payment has settled + k_EResultNeedCaptcha = 101, // Needs to provide a valid captcha + k_EResultGSLTDenied = 102, // a game server login token owned by this token's owner has been banned + k_EResultGSOwnerDenied = 103, // game server owner is denied for other reason (account lock, community ban, vac ban, missing phone) + k_EResultInvalidItemType = 104, // the type of thing we were requested to act on is invalid + k_EResultIPBanned = 105, // the ip address has been banned from taking this action + k_EResultGSLTExpired = 106, // this token has expired from disuse; can be reset for use + k_EResultInsufficientFunds = 107, // user doesn't have enough wallet funds to complete the action + k_EResultTooManyPending = 108, // There are too many of this thing pending already + k_EResultNoSiteLicensesFound = 109, // No site licenses found + k_EResultWGNetworkSendExceeded = 110, // the WG couldn't send a response because we exceeded max network send size + k_EResultAccountNotFriends = 111, // the user is not mutually friends + k_EResultLimitedUserAccount = 112, // the user is limited + k_EResultCantRemoveItem = 113, // item can't be removed + k_EResultAccountDeleted = 114, // account has been deleted + k_EResultExistingUserCancelledLicense = 115, // A license for this already exists, but cancelled + k_EResultCommunityCooldown = 116, // access is denied because of a community cooldown (probably from support profile data resets) + k_EResultNoLauncherSpecified = 117, // No launcher was specified, but a launcher was needed to choose correct realm for operation. + k_EResultMustAgreeToSSA = 118, // User must agree to china SSA or global SSA before login + k_EResultLauncherMigrated = 119, // The specified launcher type is no longer supported; the user should be directed elsewhere + k_EResultSteamRealmMismatch = 120, // The user's realm does not match the realm of the requested resource + k_EResultInvalidSignature = 121, // signature check did not match + k_EResultParseFailure = 122, // Failed to parse input + k_EResultNoVerifiedPhone = 123, // account does not have a verified phone number + k_EResultInsufficientBattery = 124, // user device doesn't have enough battery charge currently to complete the action + k_EResultChargerRequired = 125, // The operation requires a charger to be plugged in, which wasn't present + k_EResultCachedCredentialInvalid = 126, // Cached credential was invalid - user must reauthenticate + K_EResultPhoneNumberIsVOIP = 127, // The phone number provided is a Voice Over IP number + k_EResultNotSupported = 128, // The data being accessed is not supported by this API + k_EResultFamilySizeLimitExceeded = 129, // Reached the maximum size of the family +}; + +// Error codes for use with the voice functions +enum EVoiceResult +{ + k_EVoiceResultOK = 0, + k_EVoiceResultNotInitialized = 1, + k_EVoiceResultNotRecording = 2, + k_EVoiceResultNoData = 3, + k_EVoiceResultBufferTooSmall = 4, + k_EVoiceResultDataCorrupted = 5, + k_EVoiceResultRestricted = 6, + k_EVoiceResultUnsupportedCodec = 7, + k_EVoiceResultReceiverOutOfDate = 8, + k_EVoiceResultReceiverDidNotAnswer = 9, + +}; + +// Result codes to GSHandleClientDeny/Kick +enum EDenyReason +{ + k_EDenyInvalid = 0, + k_EDenyInvalidVersion = 1, + k_EDenyGeneric = 2, + k_EDenyNotLoggedOn = 3, + k_EDenyNoLicense = 4, + k_EDenyCheater = 5, + k_EDenyLoggedInElseWhere = 6, + k_EDenyUnknownText = 7, + k_EDenyIncompatibleAnticheat = 8, + k_EDenyMemoryCorruption = 9, + k_EDenyIncompatibleSoftware = 10, + k_EDenySteamConnectionLost = 11, + k_EDenySteamConnectionError = 12, + k_EDenySteamResponseTimedOut = 13, + k_EDenySteamValidationStalled = 14, + k_EDenySteamOwnerLeftGuestUser = 15, +}; + +// return type of GetAuthSessionTicket +typedef uint32 HAuthTicket; +const HAuthTicket k_HAuthTicketInvalid = 0; + +// results from BeginAuthSession +enum EBeginAuthSessionResult +{ + k_EBeginAuthSessionResultOK = 0, // Ticket is valid for this game and this steamID. + k_EBeginAuthSessionResultInvalidTicket = 1, // Ticket is not valid. + k_EBeginAuthSessionResultDuplicateRequest = 2, // A ticket has already been submitted for this steamID + k_EBeginAuthSessionResultInvalidVersion = 3, // Ticket is from an incompatible interface version + k_EBeginAuthSessionResultGameMismatch = 4, // Ticket is not for this game + k_EBeginAuthSessionResultExpiredTicket = 5, // Ticket has expired +}; + +// Callback values for callback ValidateAuthTicketResponse_t which is a response to BeginAuthSession +enum EAuthSessionResponse +{ + k_EAuthSessionResponseOK = 0, // Steam has verified the user is online, the ticket is valid and ticket has not been reused. + k_EAuthSessionResponseUserNotConnectedToSteam = 1, // The user in question is not connected to steam + k_EAuthSessionResponseNoLicenseOrExpired = 2, // The license has expired. + k_EAuthSessionResponseVACBanned = 3, // The user is VAC banned for this game. + k_EAuthSessionResponseLoggedInElseWhere = 4, // The user account has logged in elsewhere and the session containing the game instance has been disconnected. + k_EAuthSessionResponseVACCheckTimedOut = 5, // VAC has been unable to perform anti-cheat checks on this user + k_EAuthSessionResponseAuthTicketCanceled = 6, // The ticket has been canceled by the issuer + k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7, // This ticket has already been used, it is not valid. + k_EAuthSessionResponseAuthTicketInvalid = 8, // This ticket is not from a user instance currently connected to steam. + k_EAuthSessionResponsePublisherIssuedBan = 9, // The user is banned for this game. The ban came via the web api and not VAC + k_EAuthSessionResponseAuthTicketNetworkIdentityFailure = 10, // The network identity in the ticket does not match the server authenticating the ticket +}; + +// results from UserHasLicenseForApp +enum EUserHasLicenseForAppResult +{ + k_EUserHasLicenseResultHasLicense = 0, // User has a license for specified app + k_EUserHasLicenseResultDoesNotHaveLicense = 1, // User does not have a license for the specified app + k_EUserHasLicenseResultNoAuth = 2, // User has not been authenticated +}; + + +// Steam account types +enum EAccountType +{ + k_EAccountTypeInvalid = 0, + k_EAccountTypeIndividual = 1, // single user account + k_EAccountTypeMultiseat = 2, // multiseat (e.g. cybercafe) account + k_EAccountTypeGameServer = 3, // game server account + k_EAccountTypeAnonGameServer = 4, // anonymous game server account + k_EAccountTypePending = 5, // pending + k_EAccountTypeContentServer = 6, // content server + k_EAccountTypeClan = 7, + k_EAccountTypeChat = 8, + k_EAccountTypeConsoleUser = 9, // Fake SteamID for local PSN account on PS3 or Live account on 360, etc. + k_EAccountTypeAnonUser = 10, + + // Max of 16 items in this field + k_EAccountTypeMax +}; + + + +//----------------------------------------------------------------------------- +// Purpose: Chat Entry Types (previously was only friend-to-friend message types) +//----------------------------------------------------------------------------- +enum EChatEntryType +{ + k_EChatEntryTypeInvalid = 0, + k_EChatEntryTypeChatMsg = 1, // Normal text message from another user + k_EChatEntryTypeTyping = 2, // Another user is typing (not used in multi-user chat) + k_EChatEntryTypeInviteGame = 3, // Invite from other user into that users current game + k_EChatEntryTypeEmote = 4, // text emote message (deprecated, should be treated as ChatMsg) + //k_EChatEntryTypeLobbyGameStart = 5, // lobby game is starting (dead - listen for LobbyGameCreated_t callback instead) + k_EChatEntryTypeLeftConversation = 6, // user has left the conversation ( closed chat window ) + // Above are previous FriendMsgType entries, now merged into more generic chat entry types + k_EChatEntryTypeEntered = 7, // user has entered the conversation (used in multi-user chat and group chat) + k_EChatEntryTypeWasKicked = 8, // user was kicked (data: 64-bit steamid of actor performing the kick) + k_EChatEntryTypeWasBanned = 9, // user was banned (data: 64-bit steamid of actor performing the ban) + k_EChatEntryTypeDisconnected = 10, // user disconnected + k_EChatEntryTypeHistoricalChat = 11, // a chat message from user's chat history or offilne message + //k_EChatEntryTypeReserved1 = 12, // No longer used + //k_EChatEntryTypeReserved2 = 13, // No longer used + k_EChatEntryTypeLinkBlocked = 14, // a link was removed by the chat filter. +}; + + +//----------------------------------------------------------------------------- +// Purpose: Chat Room Enter Responses +//----------------------------------------------------------------------------- +enum EChatRoomEnterResponse +{ + k_EChatRoomEnterResponseSuccess = 1, // Success + k_EChatRoomEnterResponseDoesntExist = 2, // Chat doesn't exist (probably closed) + k_EChatRoomEnterResponseNotAllowed = 3, // General Denied - You don't have the permissions needed to join the chat + k_EChatRoomEnterResponseFull = 4, // Chat room has reached its maximum size + k_EChatRoomEnterResponseError = 5, // Unexpected Error + k_EChatRoomEnterResponseBanned = 6, // You are banned from this chat room and may not join + k_EChatRoomEnterResponseLimited = 7, // Joining this chat is not allowed because you are a limited user (no value on account) + k_EChatRoomEnterResponseClanDisabled = 8, // Attempt to join a clan chat when the clan is locked or disabled + k_EChatRoomEnterResponseCommunityBan = 9, // Attempt to join a chat when the user has a community lock on their account + k_EChatRoomEnterResponseMemberBlockedYou = 10, // Join failed - some member in the chat has blocked you from joining + k_EChatRoomEnterResponseYouBlockedMember = 11, // Join failed - you have blocked some member already in the chat + // k_EChatRoomEnterResponseNoRankingDataLobby = 12, // No longer used + // k_EChatRoomEnterResponseNoRankingDataUser = 13, // No longer used + // k_EChatRoomEnterResponseRankOutOfRange = 14, // No longer used + k_EChatRoomEnterResponseRatelimitExceeded = 15, // Join failed - to many join attempts in a very short period of time +}; + + +const unsigned int k_unSteamAccountIDMask = 0xFFFFFFFF; +const unsigned int k_unSteamAccountInstanceMask = 0x000FFFFF; +const unsigned int k_unSteamUserDefaultInstance = 1; // fixed instance for all individual users + +// Special flags for Chat accounts - they go in the top 8 bits +// of the steam ID's "instance", leaving 12 for the actual instances +enum EChatSteamIDInstanceFlags +{ + k_EChatAccountInstanceMask = 0x00000FFF, // top 8 bits are flags + + k_EChatInstanceFlagClan = ( k_unSteamAccountInstanceMask + 1 ) >> 1, // top bit + k_EChatInstanceFlagLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 2, // next one down, etc + k_EChatInstanceFlagMMSLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 3, // next one down, etc + + // Max of 8 flags +}; + + +//----------------------------------------------------------------------------- +// Purpose: Possible positions to tell the overlay to show notifications in +//----------------------------------------------------------------------------- +enum ENotificationPosition +{ + k_EPositionInvalid = -1, + k_EPositionTopLeft = 0, + k_EPositionTopRight = 1, + k_EPositionBottomLeft = 2, + k_EPositionBottomRight = 3, +}; + + +//----------------------------------------------------------------------------- +// Purpose: Broadcast upload result details +//----------------------------------------------------------------------------- +enum EBroadcastUploadResult +{ + k_EBroadcastUploadResultNone = 0, // broadcast state unknown + k_EBroadcastUploadResultOK = 1, // broadcast was good, no problems + k_EBroadcastUploadResultInitFailed = 2, // broadcast init failed + k_EBroadcastUploadResultFrameFailed = 3, // broadcast frame upload failed + k_EBroadcastUploadResultTimeout = 4, // broadcast upload timed out + k_EBroadcastUploadResultBandwidthExceeded = 5, // broadcast send too much data + k_EBroadcastUploadResultLowFPS = 6, // broadcast FPS too low + k_EBroadcastUploadResultMissingKeyFrames = 7, // broadcast sending not enough key frames + k_EBroadcastUploadResultNoConnection = 8, // broadcast client failed to connect to relay + k_EBroadcastUploadResultRelayFailed = 9, // relay dropped the upload + k_EBroadcastUploadResultSettingsChanged = 10, // the client changed broadcast settings + k_EBroadcastUploadResultMissingAudio = 11, // client failed to send audio data + k_EBroadcastUploadResultTooFarBehind = 12, // clients was too slow uploading + k_EBroadcastUploadResultTranscodeBehind = 13, // server failed to keep up with transcode + k_EBroadcastUploadResultNotAllowedToPlay = 14, // Broadcast does not have permissions to play game + k_EBroadcastUploadResultBusy = 15, // RTMP host to busy to take new broadcast stream, choose another + k_EBroadcastUploadResultBanned = 16, // Account banned from community broadcast + k_EBroadcastUploadResultAlreadyActive = 17, // We already already have an stream running. + k_EBroadcastUploadResultForcedOff = 18, // We explicitly shutting down a broadcast + k_EBroadcastUploadResultAudioBehind = 19, // Audio stream was too far behind video + k_EBroadcastUploadResultShutdown = 20, // Broadcast Server was shut down + k_EBroadcastUploadResultDisconnect = 21, // broadcast uploader TCP disconnected + k_EBroadcastUploadResultVideoInitFailed = 22, // invalid video settings + k_EBroadcastUploadResultAudioInitFailed = 23, // invalid audio settings +}; + + +//----------------------------------------------------------------------------- +// Purpose: Reasons a user may not use the Community Market. +// Used in MarketEligibilityResponse_t. +//----------------------------------------------------------------------------- +enum EMarketNotAllowedReasonFlags +{ + k_EMarketNotAllowedReason_None = 0, + + // A back-end call failed or something that might work again on retry + k_EMarketNotAllowedReason_TemporaryFailure = (1 << 0), + + // Disabled account + k_EMarketNotAllowedReason_AccountDisabled = (1 << 1), + + // Locked account + k_EMarketNotAllowedReason_AccountLockedDown = (1 << 2), + + // Limited account (no purchases) + k_EMarketNotAllowedReason_AccountLimited = (1 << 3), + + // The account is banned from trading items + k_EMarketNotAllowedReason_TradeBanned = (1 << 4), + + // Wallet funds aren't tradable because the user has had no purchase + // activity in the last year or has had no purchases prior to last month + k_EMarketNotAllowedReason_AccountNotTrusted = (1 << 5), + + // The user doesn't have Steam Guard enabled + k_EMarketNotAllowedReason_SteamGuardNotEnabled = (1 << 6), + + // The user has Steam Guard, but it hasn't been enabled for the required + // number of days + k_EMarketNotAllowedReason_SteamGuardOnlyRecentlyEnabled = (1 << 7), + + // The user has recently forgotten their password and reset it + k_EMarketNotAllowedReason_RecentPasswordReset = (1 << 8), + + // The user has recently funded his or her wallet with a new payment method + k_EMarketNotAllowedReason_NewPaymentMethod = (1 << 9), + + // An invalid cookie was sent by the user + k_EMarketNotAllowedReason_InvalidCookie = (1 << 10), + + // The user has Steam Guard, but is using a new computer or web browser + k_EMarketNotAllowedReason_UsingNewDevice = (1 << 11), + + // The user has recently refunded a store purchase by his or herself + k_EMarketNotAllowedReason_RecentSelfRefund = (1 << 12), + + // The user has recently funded his or her wallet with a new payment method that cannot be verified + k_EMarketNotAllowedReason_NewPaymentMethodCannotBeVerified = (1 << 13), + + // Not only is the account not trusted, but they have no recent purchases at all + k_EMarketNotAllowedReason_NoRecentPurchases = (1 << 14), + + // User accepted a wallet gift that was recently purchased + k_EMarketNotAllowedReason_AcceptedWalletGift = (1 << 15), +}; + + +// +// describes XP / progress restrictions to apply for games with duration control / +// anti-indulgence enabled for minor Steam China users. +// +// WARNING: DO NOT RENUMBER +enum EDurationControlProgress +{ + k_EDurationControlProgress_Full = 0, // Full progress + k_EDurationControlProgress_Half = 1, // deprecated - XP or persistent rewards should be halved + k_EDurationControlProgress_None = 2, // deprecated - XP or persistent rewards should be stopped + + k_EDurationControl_ExitSoon_3h = 3, // allowed 3h time since 5h gap/break has elapsed, game should exit - steam will terminate the game soon + k_EDurationControl_ExitSoon_5h = 4, // allowed 5h time in calendar day has elapsed, game should exit - steam will terminate the game soon + k_EDurationControl_ExitSoon_Night = 5, // game running after day period, game should exit - steam will terminate the game soon +}; + + +// +// describes which notification timer has expired, for steam china duration control feature +// +// WARNING: DO NOT RENUMBER +enum EDurationControlNotification +{ + k_EDurationControlNotification_None = 0, // just informing you about progress, no notification to show + k_EDurationControlNotification_1Hour = 1, // "you've been playing for N hours" + + k_EDurationControlNotification_3Hours = 2, // deprecated - "you've been playing for 3 hours; take a break" + k_EDurationControlNotification_HalfProgress = 3,// deprecated - "your XP / progress is half normal" + k_EDurationControlNotification_NoProgress = 4, // deprecated - "your XP / progress is zero" + + k_EDurationControlNotification_ExitSoon_3h = 5, // allowed 3h time since 5h gap/break has elapsed, game should exit - steam will terminate the game soon + k_EDurationControlNotification_ExitSoon_5h = 6, // allowed 5h time in calendar day has elapsed, game should exit - steam will terminate the game soon + k_EDurationControlNotification_ExitSoon_Night = 7,// game running after day period, game should exit - steam will terminate the game soon +}; + + +// +// Specifies a game's online state in relation to duration control +// +enum EDurationControlOnlineState +{ + k_EDurationControlOnlineState_Invalid = 0, // nil value + k_EDurationControlOnlineState_Offline = 1, // currently in offline play - single-player, offline co-op, etc. + k_EDurationControlOnlineState_Online = 2, // currently in online play + k_EDurationControlOnlineState_OnlineHighPri = 3, // currently in online play and requests not to be interrupted +}; + + +enum EBetaBranchFlags +{ + k_EBetaBranch_None = 0, + k_EBetaBranch_Default = 1, // this is the default branch ("public") + k_EBetaBranch_Available = 2, // this branch can be selected (available) + k_EBetaBranch_Private = 4, // this is a private branch (password protected) + k_EBetaBranch_Selected = 8, // this is the currently selected branch (active) + k_EBetaBranch_Installed = 16, // this is the currently installed branch (mounted) +}; + +#pragma pack( push, 1 ) + +#define CSTEAMID_DEFINED + +// Steam ID structure (64 bits total) +class CSteamID +{ +public: + + //----------------------------------------------------------------------------- + // Purpose: Constructor + //----------------------------------------------------------------------------- + CSteamID() + { + m_steamid.m_comp.m_unAccountID = 0; + m_steamid.m_comp.m_EAccountType = k_EAccountTypeInvalid; + m_steamid.m_comp.m_EUniverse = k_EUniverseInvalid; + m_steamid.m_comp.m_unAccountInstance = 0; + } + + + //----------------------------------------------------------------------------- + // Purpose: Constructor + // Input : unAccountID - 32-bit account ID + // eUniverse - Universe this account belongs to + // eAccountType - Type of account + //----------------------------------------------------------------------------- + CSteamID( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType ) + { + Set( unAccountID, eUniverse, eAccountType ); + } + + + //----------------------------------------------------------------------------- + // Purpose: Constructor + // Input : unAccountID - 32-bit account ID + // unAccountInstance - instance + // eUniverse - Universe this account belongs to + // eAccountType - Type of account + //----------------------------------------------------------------------------- + CSteamID( uint32 unAccountID, unsigned int unAccountInstance, EUniverse eUniverse, EAccountType eAccountType ) + { +#if defined(_SERVER) && defined(Assert) + Assert( ( k_EAccountTypeIndividual != eAccountType ) || ( unAccountInstance == k_unSteamUserDefaultInstance ) ); // enforce that for individual accounts, instance is always 1 +#endif // _SERVER + InstancedSet( unAccountID, unAccountInstance, eUniverse, eAccountType ); + } + + + //----------------------------------------------------------------------------- + // Purpose: Constructor + // Input : ulSteamID - 64-bit representation of a Steam ID + // Note: Will not accept a uint32 or int32 as input, as that is a probable mistake. + // See the stubbed out overloads in the private: section for more info. + //----------------------------------------------------------------------------- + CSteamID( uint64 ulSteamID ) + { + SetFromUint64( ulSteamID ); + } +#ifdef INT64_DIFFERENT_FROM_INT64_T + CSteamID( uint64_t ulSteamID ) + { + SetFromUint64( (uint64)ulSteamID ); + } +#endif + + + //----------------------------------------------------------------------------- + // Purpose: Sets parameters for steam ID + // Input : unAccountID - 32-bit account ID + // eUniverse - Universe this account belongs to + // eAccountType - Type of account + //----------------------------------------------------------------------------- + void Set( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType ) + { + m_steamid.m_comp.m_unAccountID = unAccountID; + m_steamid.m_comp.m_EUniverse = eUniverse; + m_steamid.m_comp.m_EAccountType = eAccountType; + + if ( eAccountType == k_EAccountTypeClan || eAccountType == k_EAccountTypeGameServer ) + { + m_steamid.m_comp.m_unAccountInstance = 0; + } + else + { + m_steamid.m_comp.m_unAccountInstance = k_unSteamUserDefaultInstance; + } + } + + + //----------------------------------------------------------------------------- + // Purpose: Sets parameters for steam ID + // Input : unAccountID - 32-bit account ID + // eUniverse - Universe this account belongs to + // eAccountType - Type of account + //----------------------------------------------------------------------------- + void InstancedSet( uint32 unAccountID, uint32 unInstance, EUniverse eUniverse, EAccountType eAccountType ) + { + m_steamid.m_comp.m_unAccountID = unAccountID; + m_steamid.m_comp.m_EUniverse = eUniverse; + m_steamid.m_comp.m_EAccountType = eAccountType; + m_steamid.m_comp.m_unAccountInstance = unInstance; + } + + + //----------------------------------------------------------------------------- + // Purpose: Initializes a steam ID from its 52 bit parts and universe/type + // Input : ulIdentifier - 52 bits of goodness + //----------------------------------------------------------------------------- + void FullSet( uint64 ulIdentifier, EUniverse eUniverse, EAccountType eAccountType ) + { + m_steamid.m_comp.m_unAccountID = ( ulIdentifier & k_unSteamAccountIDMask ); // account ID is low 32 bits + m_steamid.m_comp.m_unAccountInstance = ( ( ulIdentifier >> 32 ) & k_unSteamAccountInstanceMask ); // account instance is next 20 bits + m_steamid.m_comp.m_EUniverse = eUniverse; + m_steamid.m_comp.m_EAccountType = eAccountType; + } + + + //----------------------------------------------------------------------------- + // Purpose: Initializes a steam ID from its 64-bit representation + // Input : ulSteamID - 64-bit representation of a Steam ID + //----------------------------------------------------------------------------- + void SetFromUint64( uint64 ulSteamID ) + { + m_steamid.m_unAll64Bits = ulSteamID; + } + + + //----------------------------------------------------------------------------- + // Purpose: Clear all fields, leaving an invalid ID. + //----------------------------------------------------------------------------- + void Clear() + { + m_steamid.m_comp.m_unAccountID = 0; + m_steamid.m_comp.m_EAccountType = k_EAccountTypeInvalid; + m_steamid.m_comp.m_EUniverse = k_EUniverseInvalid; + m_steamid.m_comp.m_unAccountInstance = 0; + } + + //----------------------------------------------------------------------------- + // Purpose: Converts steam ID to its 64-bit representation + // Output : 64-bit representation of a Steam ID + //----------------------------------------------------------------------------- + uint64 ConvertToUint64() const + { + return m_steamid.m_unAll64Bits; + } + + + //----------------------------------------------------------------------------- + // Purpose: Converts the static parts of a steam ID to a 64-bit representation. + // For multiseat accounts, all instances of that account will have the + // same static account key, so they can be grouped together by the static + // account key. + // Output : 64-bit static account key + //----------------------------------------------------------------------------- + uint64 GetStaticAccountKey() const + { + // note we do NOT include the account instance (which is a dynamic property) in the static account key + return (uint64) ( ( ( (uint64) m_steamid.m_comp.m_EUniverse ) << 56 ) + ((uint64) m_steamid.m_comp.m_EAccountType << 52 ) + m_steamid.m_comp.m_unAccountID ); + } + + + //----------------------------------------------------------------------------- + // Purpose: create an anonymous game server login to be filled in by the AM + //----------------------------------------------------------------------------- + void CreateBlankAnonLogon( EUniverse eUniverse ) + { + m_steamid.m_comp.m_unAccountID = 0; + m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonGameServer; + m_steamid.m_comp.m_EUniverse = eUniverse; + m_steamid.m_comp.m_unAccountInstance = 0; + } + + + //----------------------------------------------------------------------------- + // Purpose: create an anonymous game server login to be filled in by the AM + //----------------------------------------------------------------------------- + void CreateBlankAnonUserLogon( EUniverse eUniverse ) + { + m_steamid.m_comp.m_unAccountID = 0; + m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonUser; + m_steamid.m_comp.m_EUniverse = eUniverse; + m_steamid.m_comp.m_unAccountInstance = 0; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this an anonymous game server login that will be filled in? + //----------------------------------------------------------------------------- + bool BBlankAnonAccount() const + { + return m_steamid.m_comp.m_unAccountID == 0 && BAnonAccount() && m_steamid.m_comp.m_unAccountInstance == 0; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this a game server account id? (Either persistent or anonymous) + //----------------------------------------------------------------------------- + bool BGameServerAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this a persistent (not anonymous) game server account id? + //----------------------------------------------------------------------------- + bool BPersistentGameServerAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this an anonymous game server account id? + //----------------------------------------------------------------------------- + bool BAnonGameServerAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this a content server account id? + //----------------------------------------------------------------------------- + bool BContentServerAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeContentServer; + } + + + //----------------------------------------------------------------------------- + // Purpose: Is this a clan account id? + //----------------------------------------------------------------------------- + bool BClanAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan; + } + + + //----------------------------------------------------------------------------- + // Purpose: Is this a chat account id? + //----------------------------------------------------------------------------- + bool BChatAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this a chat account id? + //----------------------------------------------------------------------------- + bool IsLobby() const + { + return ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat ) + && ( m_steamid.m_comp.m_unAccountInstance & k_EChatInstanceFlagLobby ); + } + + + //----------------------------------------------------------------------------- + // Purpose: Is this an individual user account id? + //----------------------------------------------------------------------------- + bool BIndividualAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual || m_steamid.m_comp.m_EAccountType == k_EAccountTypeConsoleUser; + } + + + //----------------------------------------------------------------------------- + // Purpose: Is this an anonymous account? + //----------------------------------------------------------------------------- + bool BAnonAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this an anonymous user account? ( used to create an account or reset a password ) + //----------------------------------------------------------------------------- + bool BAnonUserAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser; + } + + //----------------------------------------------------------------------------- + // Purpose: Is this a faked up Steam ID for a PSN friend account? + //----------------------------------------------------------------------------- + bool BConsoleUserAccount() const + { + return m_steamid.m_comp.m_EAccountType == k_EAccountTypeConsoleUser; + } + + // simple accessors + void SetAccountID( uint32 unAccountID ) { m_steamid.m_comp.m_unAccountID = unAccountID; } + void SetAccountInstance( uint32 unInstance ){ m_steamid.m_comp.m_unAccountInstance = unInstance; } + + AccountID_t GetAccountID() const { return m_steamid.m_comp.m_unAccountID; } + uint32 GetUnAccountInstance() const { return m_steamid.m_comp.m_unAccountInstance; } + EAccountType GetEAccountType() const { return ( EAccountType ) m_steamid.m_comp.m_EAccountType; } + EUniverse GetEUniverse() const { return m_steamid.m_comp.m_EUniverse; } + void SetEUniverse( EUniverse eUniverse ) { m_steamid.m_comp.m_EUniverse = eUniverse; } + bool IsValid() const; + + // this set of functions is hidden, will be moved out of class + explicit CSteamID( const char *pchSteamID, EUniverse eDefaultUniverse = k_EUniverseInvalid ); + const char * Render() const; // renders this steam ID to string + static const char * Render( uint64 ulSteamID ); // static method to render a uint64 representation of a steam ID to a string + + void SetFromString( const char *pchSteamID, EUniverse eDefaultUniverse ); + // SetFromString allows many partially-correct strings, constraining how + // we might be able to change things in the future. + // SetFromStringStrict requires the exact string forms that we support + // and is preferred when the caller knows it's safe to be strict. + // Returns whether the string parsed correctly. + bool SetFromStringStrict( const char *pchSteamID, EUniverse eDefaultUniverse ); + + inline bool operator==( const CSteamID &val ) const { return m_steamid.m_unAll64Bits == val.m_steamid.m_unAll64Bits; } + inline bool operator!=( const CSteamID &val ) const { return !operator==( val ); } + inline bool operator<( const CSteamID &val ) const { return m_steamid.m_unAll64Bits < val.m_steamid.m_unAll64Bits; } + inline bool operator>( const CSteamID &val ) const { return m_steamid.m_unAll64Bits > val.m_steamid.m_unAll64Bits; } + + // DEBUG function + bool BValidExternalSteamID() const; + +private: + // These are defined here to prevent accidental implicit conversion of a u32AccountID to a CSteamID. + // If you get a compiler error about an ambiguous constructor/function then it may be because you're + // passing a 32-bit int to a function that takes a CSteamID. You should explicitly create the SteamID + // using the correct Universe and account Type/Instance values. + CSteamID( uint32 ); + CSteamID( int32 ); + + // 64 bits total + union SteamID_t + { + struct SteamIDComponent_t + { +#ifdef VALVE_BIG_ENDIAN + EUniverse m_EUniverse : 8; // universe this account belongs to + unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference + unsigned int m_unAccountInstance : 20; // dynamic instance ID + uint32 m_unAccountID : 32; // unique account identifier +#else + uint32 m_unAccountID : 32; // unique account identifier + unsigned int m_unAccountInstance : 20; // dynamic instance ID + unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference + EUniverse m_EUniverse : 8; // universe this account belongs to +#endif + } m_comp; + + uint64 m_unAll64Bits; + } m_steamid; +}; + +inline bool CSteamID::IsValid() const +{ + if ( m_steamid.m_comp.m_EAccountType <= k_EAccountTypeInvalid || m_steamid.m_comp.m_EAccountType >= k_EAccountTypeMax ) + return false; + + if ( m_steamid.m_comp.m_EUniverse <= k_EUniverseInvalid || m_steamid.m_comp.m_EUniverse >= k_EUniverseMax ) + return false; + + if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual ) + { + if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance != k_unSteamUserDefaultInstance ) + return false; + } + + if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan ) + { + if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance != 0 ) + return false; + } + + if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer ) + { + if ( m_steamid.m_comp.m_unAccountID == 0 ) + return false; + // Any limit on instances? We use them for local users and bots + } + return true; +} + +#if defined( INCLUDED_STEAM2_USERID_STRUCTS ) + +//----------------------------------------------------------------------------- +// Purpose: Initializes a steam ID from a Steam2 ID structure +// Input: pTSteamGlobalUserID - Steam2 ID to convert +// eUniverse - universe this ID belongs to +//----------------------------------------------------------------------------- +inline CSteamID SteamIDFromSteam2UserID( TSteamGlobalUserID *pTSteamGlobalUserID, EUniverse eUniverse ) +{ + uint32 unAccountID = pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits * 2 + + pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits; + + return CSteamID( unAccountID, k_unSteamUserDefaultInstance, eUniverse, k_EAccountTypeIndividual ); +} + +bool SteamIDFromSteam2String( const char *pchSteam2ID, EUniverse eUniverse, CSteamID *pSteamIDOut ); + +//----------------------------------------------------------------------------- +// Purpose: Fills out a Steam2 ID structure +// Input: pTSteamGlobalUserID - Steam2 ID to write to +//----------------------------------------------------------------------------- +inline TSteamGlobalUserID SteamIDToSteam2UserID( CSteamID steamID ) +{ + TSteamGlobalUserID steamGlobalUserID; + + steamGlobalUserID.m_SteamInstanceID = 0; + steamGlobalUserID.m_SteamLocalUserID.Split.High32bits = steamID.GetAccountID() % 2; + steamGlobalUserID.m_SteamLocalUserID.Split.Low32bits = steamID.GetAccountID() / 2; + + return steamGlobalUserID; +} + + +#endif + +// generic invalid CSteamID +#define k_steamIDNil CSteamID() + +// This steamID comes from a user game connection to an out of date GS that hasnt implemented the protocol +// to provide its steamID +#define k_steamIDOutofDateGS CSteamID( 0, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ) +// This steamID comes from a user game connection to an sv_lan GS +#define k_steamIDLanModeGS CSteamID( 0, 0, k_EUniversePublic, k_EAccountTypeInvalid ) +// This steamID can come from a user game connection to a GS that has just booted but hasnt yet even initialized +// its steam3 component and started logging on. +#define k_steamIDNotInitYetGS CSteamID( 1, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ) +// This steamID can come from a user game connection to a GS that isn't using the steam authentication system but still +// wants to support the "Join Game" option in the friends list +#define k_steamIDNonSteamGS CSteamID( 2, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ) + + +#ifdef STEAM +// Returns the matching chat steamID, with the default instance of 0 +// If the steamID passed in is already of type k_EAccountTypeChat it will be returned with the same instance +CSteamID ChatIDFromSteamID( const CSteamID &steamID ); +// Returns the matching clan steamID, with the default instance of 0 +// If the steamID passed in is already of type k_EAccountTypeClan it will be returned with the same instance +CSteamID ClanIDFromSteamID( const CSteamID &steamID ); +// Asserts steamID type before conversion +CSteamID ChatIDFromClanID( const CSteamID &steamIDClan ); +// Asserts steamID type before conversion +CSteamID ClanIDFromChatID( const CSteamID &steamIDChat ); + +#endif // _STEAM + + +//----------------------------------------------------------------------------- +// Purpose: encapsulates an appID/modID pair +//----------------------------------------------------------------------------- +class CGameID +{ +public: + + enum EGameIDType + { + k_EGameIDTypeApp = 0, + k_EGameIDTypeGameMod = 1, + k_EGameIDTypeShortcut = 2, + k_EGameIDTypeP2P = 3, + }; + + CGameID() + { + m_gameID.m_nType = k_EGameIDTypeApp; + m_gameID.m_nAppID = k_uAppIdInvalid; + m_gameID.m_nModID = 0; + } + + explicit CGameID( uint64 ulGameID ) + { + m_ulGameID = ulGameID; + } +#ifdef INT64_DIFFERENT_FROM_INT64_T + CGameID( uint64_t ulGameID ) + { + m_ulGameID = (uint64)ulGameID; + } +#endif + + explicit CGameID( int32 nAppID ) + { + m_ulGameID = 0; + m_gameID.m_nAppID = nAppID; + } + + explicit CGameID( uint32 nAppID ) + { + m_ulGameID = 0; + m_gameID.m_nAppID = nAppID; + } + + // Not validating anything .. use IsValid() + explicit CGameID( uint32 nAppID, uint32 nModID, CGameID::EGameIDType nType ) + { + m_gameID.m_nAppID = nAppID; + m_gameID.m_nModID = nModID; + m_gameID.m_nType = nType; + } + + CGameID( const CGameID &that ) + { + m_ulGameID = that.m_ulGameID; + } + + CGameID& operator=( const CGameID & that ) + { + m_ulGameID = that.m_ulGameID; + return *this; + } + + // Hidden functions used only by Steam + explicit CGameID( const char *pchGameID ); + const char *Render() const; // render this Game ID to string + static const char *Render( uint64 ulGameID ); // static method to render a uint64 representation of a Game ID to a string + + uint64 ToUint64() const + { + return m_ulGameID; + } + + uint64 *GetUint64Ptr() + { + return &m_ulGameID; + } + + void Set( uint64 ulGameID ) + { + m_ulGameID = ulGameID; + } + + bool IsMod() const + { + return ( m_gameID.m_nType == k_EGameIDTypeGameMod ); + } + + bool IsShortcut() const + { + return ( m_gameID.m_nType == k_EGameIDTypeShortcut ); + } + + bool IsP2PFile() const + { + return ( m_gameID.m_nType == k_EGameIDTypeP2P ); + } + + bool IsSteamApp() const + { + return ( m_gameID.m_nType == k_EGameIDTypeApp ); + } + + uint32 ModID() const + { + return m_gameID.m_nModID; + } + +#if !defined(VALVE_SHORTCUT_DEBUG) + uint32 AppID( bool = false ) const + { + return m_gameID.m_nAppID; + } +#else + uint32 AppID( bool bShortcutOK = false ) const; +#endif + + bool operator == ( const CGameID &rhs ) const + { + return m_ulGameID == rhs.m_ulGameID; + } + + bool operator != ( const CGameID &rhs ) const + { + return !(*this == rhs); + } + + bool operator < ( const CGameID &rhs ) const + { + return ( m_ulGameID < rhs.m_ulGameID ); + } + + bool IsValid() const + { + // each type has it's own invalid fixed point: + switch( m_gameID.m_nType ) + { + case k_EGameIDTypeApp: + return m_gameID.m_nAppID != k_uAppIdInvalid; + + case k_EGameIDTypeGameMod: + return m_gameID.m_nAppID != k_uAppIdInvalid && (m_gameID.m_nModID & 0x80000000); + + case k_EGameIDTypeShortcut: + return m_gameID.m_nAppID == k_uAppIdInvalid + && (m_gameID.m_nModID & 0x80000000) + && m_gameID.m_nModID >= (5000 | 0x80000000); // k_unMaxExpectedLocalAppId - shortcuts are pushed beyond that range + + case k_EGameIDTypeP2P: + return m_gameID.m_nAppID == k_uAppIdInvalid && (m_gameID.m_nModID & 0x80000000); + + default: + return false; + } + + } + + void Reset() + { + m_ulGameID = 0; + } + +// +// Internal stuff. Use the accessors above if possible +// + + struct GameID_t + { +#ifdef VALVE_BIG_ENDIAN + unsigned int m_nModID : 32; + unsigned int m_nType : 8; + unsigned int m_nAppID : 24; +#else + unsigned int m_nAppID : 24; + unsigned int m_nType : 8; + unsigned int m_nModID : 32; +#endif + }; + + union + { + uint64 m_ulGameID; + GameID_t m_gameID; + }; + + friend CGameID GameIDFromAppAndModPath( uint32 nAppID, const char *pchModPath ); +}; + +#pragma pack( pop ) + +const int k_cchGameExtraInfoMax = 64; + + +//----------------------------------------------------------------------------- +// Purpose: Passed as argument to SteamAPI_UseBreakpadCrashHandler to enable optional callback +// just before minidump file is captured after a crash has occurred. (Allows app to append additional comment data to the dump, etc.) +//----------------------------------------------------------------------------- +typedef void (*PFNPreMinidumpCallback)(void *context); + +enum EGameSearchErrorCode_t +{ + k_EGameSearchErrorCode_OK = 1, + k_EGameSearchErrorCode_Failed_Search_Already_In_Progress = 2, + k_EGameSearchErrorCode_Failed_No_Search_In_Progress = 3, + k_EGameSearchErrorCode_Failed_Not_Lobby_Leader = 4, // if not the lobby leader can not call SearchForGameWithLobby + k_EGameSearchErrorCode_Failed_No_Host_Available = 5, // no host is available that matches those search params + k_EGameSearchErrorCode_Failed_Search_Params_Invalid = 6, // search params are invalid + k_EGameSearchErrorCode_Failed_Offline = 7, // offline, could not communicate with server + k_EGameSearchErrorCode_Failed_NotAuthorized = 8, // either the user or the application does not have priveledges to do this + k_EGameSearchErrorCode_Failed_Unknown_Error = 9, // unknown error +}; + +enum EPlayerResult_t +{ + k_EPlayerResultFailedToConnect = 1, // failed to connect after confirming + k_EPlayerResultAbandoned = 2, // quit game without completing it + k_EPlayerResultKicked = 3, // kicked by other players/moderator/server rules + k_EPlayerResultIncomplete = 4, // player stayed to end but game did not conclude successfully ( nofault to player ) + k_EPlayerResultCompleted = 5, // player completed game +}; + + +enum ESteamIPv6ConnectivityProtocol +{ + k_ESteamIPv6ConnectivityProtocol_Invalid = 0, + k_ESteamIPv6ConnectivityProtocol_HTTP = 1, // because a proxy may make this different than other protocols + k_ESteamIPv6ConnectivityProtocol_UDP = 2, // test UDP connectivity. Uses a port that is commonly needed for other Steam stuff. If UDP works, TCP probably works. +}; + +// For the above transport protocol, what do we think the local machine's connectivity to the internet over ipv6 is like +enum ESteamIPv6ConnectivityState +{ + k_ESteamIPv6ConnectivityState_Unknown = 0, // We haven't run a test yet + k_ESteamIPv6ConnectivityState_Good = 1, // We have recently been able to make a request on ipv6 for the given protocol + k_ESteamIPv6ConnectivityState_Bad = 2, // We failed to make a request, either because this machine has no ipv6 address assigned, or it has no upstream connectivity +}; + + +// Define compile time assert macros to let us validate the structure sizes. +#define VALVE_COMPILE_TIME_ASSERT( pred ) typedef char compile_time_assert_type[(pred) ? 1 : -1]; + +#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) +// The 32-bit version of gcc has the alignment requirement for uint64 and double set to +// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned. +// The 64-bit version of gcc has the alignment requirement for these types set to +// 8 meaning that unless we use #pragma pack(4) our structures will get bigger. +// The 64-bit structure packing has to match the 32-bit structure packing for each platform. +#define VALVE_CALLBACK_PACK_SMALL +#else +#define VALVE_CALLBACK_PACK_LARGE +#endif + +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error ??? +#endif + +typedef struct ValvePackingSentinel_t +{ + uint32 m_u32; + uint64 m_u64; + uint16 m_u16; + double m_d; +} ValvePackingSentinel_t; + +#pragma pack( pop ) + + +#if defined(VALVE_CALLBACK_PACK_SMALL) +VALVE_COMPILE_TIME_ASSERT( sizeof(ValvePackingSentinel_t) == 24 ) +#elif defined(VALVE_CALLBACK_PACK_LARGE) +VALVE_COMPILE_TIME_ASSERT( sizeof(ValvePackingSentinel_t) == 32 ) +#else +#error ??? +#endif + +#endif // STEAMCLIENTPUBLIC_H diff --git a/lsteamclient/steamworks_sdk_160/steamencryptedappticket.h b/lsteamclient/steamworks_sdk_160/steamencryptedappticket.h new file mode 100644 index 0000000000..4419a0bec8 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamencryptedappticket.h @@ -0,0 +1,40 @@ +//========= Copyright © 1996-2010, Valve LLC, All rights reserved. ============ +// +// Purpose: utilities to decode/decrypt a ticket from the +// ISteamUser::RequestEncryptedAppTicket, ISteamUser::GetEncryptedAppTicket API +// +// To use: declare CSteamEncryptedAppTicket, then call BDecryptTicket +// if BDecryptTicket returns true, other accessors are valid +// +//============================================================================= + +#include "steam_api.h" + +static const int k_nSteamEncryptedAppTicketSymmetricKeyLen = 32; + + +S_API bool SteamEncryptedAppTicket_BDecryptTicket( const uint8 *rgubTicketEncrypted, uint32 cubTicketEncrypted, + uint8 *rgubTicketDecrypted, uint32 *pcubTicketDecrypted, + const uint8 rgubKey[k_nSteamEncryptedAppTicketSymmetricKeyLen], int cubKey ); + +S_API bool SteamEncryptedAppTicket_BIsTicketForApp( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID ); + +S_API RTime32 SteamEncryptedAppTicket_GetTicketIssueTime( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); + +S_API void SteamEncryptedAppTicket_GetTicketSteamID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, CSteamID *psteamID ); + +S_API AppId_t SteamEncryptedAppTicket_GetTicketAppID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); + +S_API bool SteamEncryptedAppTicket_BUserOwnsAppInTicket( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID ); + +S_API bool SteamEncryptedAppTicket_BUserIsVacBanned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); + +S_API bool SteamEncryptedAppTicket_BGetAppDefinedValue( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, uint32 *pValue ); + +S_API const uint8 *SteamEncryptedAppTicket_GetUserVariableData( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, uint32 *pcubUserData ); + +S_API bool SteamEncryptedAppTicket_BIsTicketSigned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, const uint8 *pubRSAKey, uint32 cubRSAKey ); + +S_API bool SteamEncryptedAppTicket_BIsLicenseBorrowed( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); + +S_API bool SteamEncryptedAppTicket_BIsLicenseTemporary( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); diff --git a/lsteamclient/steamworks_sdk_160/steamhttpenums.h b/lsteamclient/steamworks_sdk_160/steamhttpenums.h new file mode 100644 index 0000000000..3592116a18 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamhttpenums.h @@ -0,0 +1,105 @@ +//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. ======= +// +// Purpose: HTTP related enums, stuff that is shared by both clients and servers, and our +// UI projects goes here. +// +//============================================================================= + +#ifndef STEAMHTTPENUMS_H +#define STEAMHTTPENUMS_H +#ifdef _WIN32 +#pragma once +#endif + +// HTTP related types + +// This enum is used in client API methods, do not re-number existing values. +enum EHTTPMethod +{ + k_EHTTPMethodInvalid = 0, + k_EHTTPMethodGET, + k_EHTTPMethodHEAD, + k_EHTTPMethodPOST, + k_EHTTPMethodPUT, + k_EHTTPMethodDELETE, + k_EHTTPMethodOPTIONS, + k_EHTTPMethodPATCH, + + // The remaining HTTP methods are not yet supported, per rfc2616 section 5.1.1 only GET and HEAD are required for + // a compliant general purpose server. We'll likely add more as we find uses for them. + + // k_EHTTPMethodTRACE, + // k_EHTTPMethodCONNECT +}; + + +// HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions +// of each of these. +enum EHTTPStatusCode +{ + // Invalid status code (this isn't defined in HTTP, used to indicate unset in our code) + k_EHTTPStatusCodeInvalid = 0, + + // Informational codes + k_EHTTPStatusCode100Continue = 100, + k_EHTTPStatusCode101SwitchingProtocols = 101, + + // Success codes + k_EHTTPStatusCode200OK = 200, + k_EHTTPStatusCode201Created = 201, + k_EHTTPStatusCode202Accepted = 202, + k_EHTTPStatusCode203NonAuthoritative = 203, + k_EHTTPStatusCode204NoContent = 204, + k_EHTTPStatusCode205ResetContent = 205, + k_EHTTPStatusCode206PartialContent = 206, + + // Redirection codes + k_EHTTPStatusCode300MultipleChoices = 300, + k_EHTTPStatusCode301MovedPermanently = 301, + k_EHTTPStatusCode302Found = 302, + k_EHTTPStatusCode303SeeOther = 303, + k_EHTTPStatusCode304NotModified = 304, + k_EHTTPStatusCode305UseProxy = 305, + //k_EHTTPStatusCode306Unused = 306, (used in old HTTP spec, now unused in 1.1) + k_EHTTPStatusCode307TemporaryRedirect = 307, + k_EHTTPStatusCode308PermanentRedirect = 308, + + // Error codes + k_EHTTPStatusCode400BadRequest = 400, + k_EHTTPStatusCode401Unauthorized = 401, // You probably want 403 or something else. 401 implies you're sending a WWW-Authenticate header and the client can sent an Authorization header in response. + k_EHTTPStatusCode402PaymentRequired = 402, // This is reserved for future HTTP specs, not really supported by clients + k_EHTTPStatusCode403Forbidden = 403, + k_EHTTPStatusCode404NotFound = 404, + k_EHTTPStatusCode405MethodNotAllowed = 405, + k_EHTTPStatusCode406NotAcceptable = 406, + k_EHTTPStatusCode407ProxyAuthRequired = 407, + k_EHTTPStatusCode408RequestTimeout = 408, + k_EHTTPStatusCode409Conflict = 409, + k_EHTTPStatusCode410Gone = 410, + k_EHTTPStatusCode411LengthRequired = 411, + k_EHTTPStatusCode412PreconditionFailed = 412, + k_EHTTPStatusCode413RequestEntityTooLarge = 413, + k_EHTTPStatusCode414RequestURITooLong = 414, + k_EHTTPStatusCode415UnsupportedMediaType = 415, + k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416, + k_EHTTPStatusCode417ExpectationFailed = 417, + k_EHTTPStatusCode4xxUnknown = 418, // 418 is reserved, so we'll use it to mean unknown + k_EHTTPStatusCode429TooManyRequests = 429, + k_EHTTPStatusCode444ConnectionClosed = 444, // nginx only? + + // Server error codes + k_EHTTPStatusCode500InternalServerError = 500, + k_EHTTPStatusCode501NotImplemented = 501, + k_EHTTPStatusCode502BadGateway = 502, + k_EHTTPStatusCode503ServiceUnavailable = 503, + k_EHTTPStatusCode504GatewayTimeout = 504, + k_EHTTPStatusCode505HTTPVersionNotSupported = 505, + k_EHTTPStatusCode5xxUnknown = 599, +}; + +inline bool BIsHTTPStatusSuccess( EHTTPStatusCode eStatus ) +{ + return eStatus >= 200 && eStatus <= 299; +} + +#endif // STEAMHTTPENUMS_H \ No newline at end of file diff --git a/lsteamclient/steamworks_sdk_160/steamnetworkingfakeip.h b/lsteamclient/steamworks_sdk_160/steamnetworkingfakeip.h new file mode 100644 index 0000000000..0b642734fc --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamnetworkingfakeip.h @@ -0,0 +1,135 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== + +#ifndef STEAMNETWORKINGFAKEIP_H +#define STEAMNETWORKINGFAKEIP_H + +#include "steamnetworkingtypes.h" +#include "steam_api_common.h" + +// It is HIGHLY recommended to limit messages sent via Fake UDP port to this +// value. The purpose of a Fake UDP port is to make porting ordinary ad-hoc UDP +// code easier. Although the real MTU might be higher than this, this particular +// conservative value is chosen so that fragmentation won't be occurring and +// hiding performance problems from you. +constexpr int k_cbSteamNetworkingSocketsFakeUDPPortRecommendedMTU = 1200; + +// Messages larger than this size are not allowed and cannot be sent +// via Fake UDP port. +constexpr int k_cbSteamNetworkingSocketsFakeUDPPortMaxMessageSize = 4096; + +//----------------------------------------------------------------------------- +/// ISteamNetworkingFakeUDPPort +/// +/// Acts like a UDP port, sending and receiving datagrams addressed using +/// FakeIP addresses. +/// +/// See: ISteamNetworkingSockets::CreateFakeUDPPort + +class ISteamNetworkingFakeUDPPort +{ +public: + /// Destroy the object and cleanup any internal connections. + /// Note that this function call is not threadsafe with respect + /// to any other method of this interface. (However, in general + /// all other operations are threadsafe with respect to each other.) + virtual void DestroyFakeUDPPort() = 0; + + /// Send a datagram to the specified FakeIP. + /// + /// See ISteamNetworkingSockets::SendMessageToConnection for the meaning of + /// nSendFlags and possible return codes. + /// + /// Notes: + /// - datagrams larger than the underlying MTU are supported, but + /// reliable messages (k_nSteamNetworkingSend_Reliable) are not supported. + /// - You will usually want to use k_nSteamNetworkingSend_NoNagle + /// - k_EResultBusy is returned if this is a "server" port and the global + /// allocation has not yet completed. + /// - k_EResultIPNotFound will be returned if the address is a local/ephemeral + /// address and no existing connection can be found. This can happen if + /// the remote host contacted us without having a global address, and we + /// assigned them a random local address, and then the session with + /// that host timed out. + /// - When initiating communications, the first messages may be sent + /// via backend signaling, or otherwise delayed, while a route is found. + /// Expect the ping time to fluctuate during this period, and it's possible + /// that messages will be delivered out of order (which is also possible with + /// ordinary UDP). + virtual EResult SendMessageToFakeIP( const SteamNetworkingIPAddr &remoteAddress, const void *pData, uint32 cbData, int nSendFlags ) = 0; + + /// Receive messages on the port. + /// + /// Returns the number of messages returned into your array, up to nMaxMessages. + /// + /// SteamNetworkingMessage_t::m_identity in the returned message(s) will always contain + /// a FakeIP. See ISteamNetworkingUtils::GetRealIdentityForFakeIP. + virtual int ReceiveMessages( SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0; + + /// Schedule the internal connection for a given peer to be cleaned up in a few seconds. + /// + /// Idle connections automatically time out, and so this is not strictly *necessary*, + /// but if you have reason to believe that you are done talking to a given peer for + /// a while, you can call this to speed up the timeout. If any remaining packets are + /// sent or received from the peer, the cleanup is canceled and the usual timeout + /// value is restored. Thus you will usually call this immediately after sending + /// or receiving application-layer "close connection" packets. + virtual void ScheduleCleanup( const SteamNetworkingIPAddr &remoteAddress ) = 0; +}; +#define STEAMNETWORKINGFAKEUDPPORT_INTERFACE_VERSION "SteamNetworkingFakeUDPPort001" /* for proton codegen */ + +/// Callback struct used to notify when a connection has changed state +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error "Must define VALVE_CALLBACK_PACK_SMALL or VALVE_CALLBACK_PACK_LARGE" +#endif + +/// A struct used to describe a "fake IP" we have been assigned to +/// use as an identifier. This callback is posted when +/// ISteamNetworkingSoockets::BeginAsyncRequestFakeIP completes. +/// See also ISteamNetworkingSockets::GetFakeIP +struct SteamNetworkingFakeIPResult_t +{ + enum { k_iCallback = k_iSteamNetworkingSocketsCallbacks + 3 }; + + /// Status/result of the allocation request. Possible failure values are: + /// - k_EResultBusy - you called GetFakeIP but the request has not completed. + /// - k_EResultInvalidParam - you called GetFakeIP with an invalid port index + /// - k_EResultLimitExceeded - You asked for too many ports, or made an + /// additional request after one had already succeeded + /// - k_EResultNoMatch - GetFakeIP was called, but no request has been made + /// + /// Note that, with the exception of k_EResultBusy (if you are polling), + /// it is highly recommended to treat all failures as fatal. + EResult m_eResult; + + /// Local identity of the ISteamNetworkingSockets object that made + /// this request and is assigned the IP. This is needed in the callback + /// in the case where there are multiple ISteamNetworkingSockets objects. + /// (E.g. one for the user, and another for the local gameserver). + SteamNetworkingIdentity m_identity; + + /// Fake IPv4 IP address that we have been assigned. NOTE: this + /// IP address is not exclusively ours! Steam tries to avoid sharing + /// IP addresses, but this may not always be possible. The IP address + /// may be currently in use by another host, but with different port(s). + /// The exact same IP:port address may have been used previously. + /// Steam tries to avoid reusing ports until they have not been in use for + /// some time, but this may not always be possible. + uint32 m_unIP; + + /// Port number(s) assigned to us. Only the first entries will contain + /// nonzero values. Entries corresponding to ports beyond what was + /// allocated for you will be zero. + /// + /// (NOTE: At the time of this writing, the maximum number of ports you may + /// request is 4.) + enum { k_nMaxReturnPorts = 8 }; + uint16 m_unPorts[k_nMaxReturnPorts]; +}; + +#pragma pack( pop ) + +#endif // _H diff --git a/lsteamclient/steamworks_sdk_160/steamnetworkingtypes.h b/lsteamclient/steamworks_sdk_160/steamnetworkingtypes.h new file mode 100644 index 0000000000..d2f9a0f69d --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamnetworkingtypes.h @@ -0,0 +1,1880 @@ +//====== Copyright Valve Corporation, All rights reserved. ==================== +// +// Purpose: misc networking utilities +// +//============================================================================= + +#ifndef STEAMNETWORKINGTYPES +#define STEAMNETWORKINGTYPES + +#include +#include +#include "steamtypes.h" +#include "steamclientpublic.h" + +//----------------------------------------------------------------------------- +// SteamNetworkingSockets config. +#if !defined(STEAMNETWORKINGSOCKETS_STANDALONELIB) && !defined(STEAMNETWORKINGSOCKETS_STEAMAPI) + #define STEAMNETWORKINGSOCKETS_STEAMAPI +#endif +//----------------------------------------------------------------------------- + +#ifdef NN_NINTENDO_SDK // We always static link on Nintendo + #define STEAMNETWORKINGSOCKETS_STATIC_LINK +#endif +#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) + #define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" +#elif defined( STEAMNETWORKINGSOCKETS_FOREXPORT ) + #if defined( _WIN32 ) || defined( __ORBIS__ ) || defined( __PROSPERO__ ) + #define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __declspec( dllexport ) + #else + #define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __attribute__((visibility("default"))) + #endif +#else + #ifdef _WIN32 + #define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __declspec( dllimport ) + #else + #define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" + #endif +#endif + +#if defined( VALVE_CALLBACK_PACK_SMALL ) +#pragma pack( push, 4 ) +#elif defined( VALVE_CALLBACK_PACK_LARGE ) +#pragma pack( push, 8 ) +#else +#error "Must define VALVE_CALLBACK_PACK_SMALL or VALVE_CALLBACK_PACK_LARGE" +#endif + +struct SteamDatagramRelayAuthTicket; +struct SteamDatagramHostedAddress; +struct SteamDatagramGameCoordinatorServerLogin; +struct SteamNetConnectionStatusChangedCallback_t; +struct SteamNetAuthenticationStatus_t; +struct SteamRelayNetworkStatus_t; +struct SteamNetworkingMessagesSessionRequest_t; +struct SteamNetworkingMessagesSessionFailed_t; +struct SteamNetworkingFakeIPResult_t; + +typedef void (*FnSteamNetConnectionStatusChanged)( SteamNetConnectionStatusChangedCallback_t * ); +typedef void (*FnSteamNetAuthenticationStatusChanged)( SteamNetAuthenticationStatus_t * ); +typedef void (*FnSteamRelayNetworkStatusChanged)(SteamRelayNetworkStatus_t *); +typedef void (*FnSteamNetworkingMessagesSessionRequest)(SteamNetworkingMessagesSessionRequest_t *); +typedef void (*FnSteamNetworkingMessagesSessionFailed)(SteamNetworkingMessagesSessionFailed_t *); +typedef void (*FnSteamNetworkingFakeIPResult)(SteamNetworkingFakeIPResult_t *); + +/// Handle used to identify a connection to a remote host. +typedef uint32 HSteamNetConnection; +const HSteamNetConnection k_HSteamNetConnection_Invalid = 0; + +/// Handle used to identify a "listen socket". Unlike traditional +/// Berkeley sockets, a listen socket and a connection are two +/// different abstractions. +typedef uint32 HSteamListenSocket; +const HSteamListenSocket k_HSteamListenSocket_Invalid = 0; + +/// Handle used to identify a poll group, used to query many +/// connections at once efficiently. +typedef uint32 HSteamNetPollGroup; +const HSteamNetPollGroup k_HSteamNetPollGroup_Invalid = 0; + +/// Max length of diagnostic error message +const int k_cchMaxSteamNetworkingErrMsg = 1024; + +/// Used to return English-language diagnostic error messages to caller. +/// (For debugging or spewing to a console, etc. Not intended for UI.) +typedef char SteamNetworkingErrMsg[ k_cchMaxSteamNetworkingErrMsg ]; + +/// Identifier used for a network location point of presence. (E.g. a Valve data center.) +/// Typically you won't need to directly manipulate these. +typedef uint32 SteamNetworkingPOPID; + +/// A local timestamp. You can subtract two timestamps to get the number of elapsed +/// microseconds. This is guaranteed to increase over time during the lifetime +/// of a process, but not globally across runs. You don't need to worry about +/// the value wrapping around. Note that the underlying clock might not actually have +/// microsecond resolution. +typedef int64 SteamNetworkingMicroseconds; + +/// Describe the status of a particular network resource +enum ESteamNetworkingAvailability +{ + // Negative values indicate a problem. + // + // In general, we will not automatically retry unless you take some action that + // depends on of requests this resource, such as querying the status, attempting + // to initiate a connection, receive a connection, etc. If you do not take any + // action at all, we do not automatically retry in the background. + k_ESteamNetworkingAvailability_CannotTry = -102, // A dependent resource is missing, so this service is unavailable. (E.g. we cannot talk to routers because Internet is down or we don't have the network config.) + k_ESteamNetworkingAvailability_Failed = -101, // We have tried for enough time that we would expect to have been successful by now. We have never been successful + k_ESteamNetworkingAvailability_Previously = -100, // We tried and were successful at one time, but now it looks like we have a problem + + k_ESteamNetworkingAvailability_Retrying = -10, // We previously failed and are currently retrying + + // Not a problem, but not ready either + k_ESteamNetworkingAvailability_NeverTried = 1, // We don't know because we haven't ever checked/tried + k_ESteamNetworkingAvailability_Waiting = 2, // We're waiting on a dependent resource to be acquired. (E.g. we cannot obtain a cert until we are logged into Steam. We cannot measure latency to relays until we have the network config.) + k_ESteamNetworkingAvailability_Attempting = 3, // We're actively trying now, but are not yet successful. + + k_ESteamNetworkingAvailability_Current = 100, // Resource is online/available + + + k_ESteamNetworkingAvailability_Unknown = 0, // Internal dummy/sentinel, or value is not applicable in this context + k_ESteamNetworkingAvailability__Force32bit = 0x7fffffff, +}; + +// +// Describing network hosts +// + +/// Different methods of describing the identity of a network host +enum ESteamNetworkingIdentityType +{ + // Dummy/empty/invalid. + // Please note that if we parse a string that we don't recognize + // but that appears reasonable, we will NOT use this type. Instead + // we'll use k_ESteamNetworkingIdentityType_UnknownType. + k_ESteamNetworkingIdentityType_Invalid = 0, + + // + // Basic platform-specific identifiers. + // + k_ESteamNetworkingIdentityType_SteamID = 16, // 64-bit CSteamID + k_ESteamNetworkingIdentityType_XboxPairwiseID = 17, // Publisher-specific user identity, as string + k_ESteamNetworkingIdentityType_SonyPSN = 18, // 64-bit ID + k_ESteamNetworkingIdentityType_GoogleStadia = 19, // 64-bit ID + //k_ESteamNetworkingIdentityType_NintendoNetworkServiceAccount, + //k_ESteamNetworkingIdentityType_EpicGameStore + //k_ESteamNetworkingIdentityType_WeGame + + // + // Special identifiers. + // + + // Use their IP address (and port) as their "identity". + // These types of identities are always unauthenticated. + // They are useful for porting plain sockets code, and other + // situations where you don't care about authentication. In this + // case, the local identity will be "localhost", + // and the remote address will be their network address. + // + // We use the same type for either IPv4 or IPv6, and + // the address is always store as IPv6. We use IPv4 + // mapped addresses to handle IPv4. + k_ESteamNetworkingIdentityType_IPAddress = 1, + + // Generic string/binary blobs. It's up to your app to interpret this. + // This library can tell you if the remote host presented a certificate + // signed by somebody you have chosen to trust, with this identity on it. + // It's up to you to ultimately decide what this identity means. + k_ESteamNetworkingIdentityType_GenericString = 2, + k_ESteamNetworkingIdentityType_GenericBytes = 3, + + // This identity type is used when we parse a string that looks like is a + // valid identity, just of a kind that we don't recognize. In this case, we + // can often still communicate with the peer! Allowing such identities + // for types we do not recognize useful is very useful for forward + // compatibility. + k_ESteamNetworkingIdentityType_UnknownType = 4, + + // Make sure this enum is stored in an int. + k_ESteamNetworkingIdentityType__Force32bit = 0x7fffffff, +}; + +/// "Fake IPs" are assigned to hosts, to make it easier to interface with +/// older code that assumed all hosts will have an IPv4 address +enum ESteamNetworkingFakeIPType +{ + k_ESteamNetworkingFakeIPType_Invalid, // Error, argument was not even an IP address, etc. + k_ESteamNetworkingFakeIPType_NotFake, // Argument was a valid IP, but was not from the reserved "fake" range + k_ESteamNetworkingFakeIPType_GlobalIPv4, // Globally unique (for a given app) IPv4 address. Address space managed by Steam + k_ESteamNetworkingFakeIPType_LocalIPv4, // Locally unique IPv4 address. Address space managed by the local process. For internal use only; should not be shared! + + k_ESteamNetworkingFakeIPType__Force32Bit = 0x7fffffff +}; + +#pragma pack(push,1) + +/// Store an IP and port. IPv6 is always used; IPv4 is represented using +/// "IPv4-mapped" addresses: IPv4 aa.bb.cc.dd => IPv6 ::ffff:aabb:ccdd +/// (RFC 4291 section 2.5.5.2.) +struct SteamNetworkingIPAddr +{ + void Clear(); // Set everything to zero. E.g. [::]:0 + bool IsIPv6AllZeros() const; // Return true if the IP is ::0. (Doesn't check port.) + void SetIPv6( const uint8 *ipv6, uint16 nPort ); // Set IPv6 address. IP is interpreted as bytes, so there are no endian issues. (Same as inaddr_in6.) The IP can be a mapped IPv4 address + void SetIPv4( uint32 nIP, uint16 nPort ); // Sets to IPv4 mapped address. IP and port are in host byte order. + bool IsIPv4() const; // Return true if IP is mapped IPv4 + uint32 GetIPv4() const; // Returns IP in host byte order (e.g. aa.bb.cc.dd as 0xaabbccdd). Returns 0 if IP is not mapped IPv4. + void SetIPv6LocalHost( uint16 nPort = 0); // Set to the IPv6 localhost address ::1, and the specified port. + bool IsLocalHost() const; // Return true if this identity is localhost. (Either IPv6 ::1, or IPv4 127.0.0.1) + + // Max length of the buffer needed to hold IP formatted using ToString, including '\0' + // ([0123:4567:89ab:cdef:0123:4567:89ab:cdef]:12345) + enum { k_cchMaxString = 48 }; + + /// Print to a string, with or without the port. Mapped IPv4 addresses are printed + /// as dotted decimal (12.34.56.78), otherwise this will print the canonical + /// form according to RFC5952. If you include the port, IPv6 will be surrounded by + /// brackets, e.g. [::1:2]:80. Your buffer should be at least k_cchMaxString bytes + /// to avoid truncation + /// + /// See also SteamNetworkingIdentityRender + inline void ToString( char *buf, size_t cbBuf, bool bWithPort ) const; + + /// Parse an IP address and optional port. If a port is not present, it is set to 0. + /// (This means that you cannot tell if a zero port was explicitly specified.) + inline bool ParseString( const char *pszStr ); + + /// RFC4038, section 4.2 + struct IPv4MappedAddress { + uint64 m_8zeros; + uint16 m_0000; + uint16 m_ffff; + uint8 m_ip[ 4 ]; // NOTE: As bytes, i.e. network byte order + }; + + union + { + uint8 m_ipv6[ 16 ]; + IPv4MappedAddress m_ipv4; + } data; + uint16 m_port; // Host byte order + + /// See if two addresses are identical + bool operator==(const SteamNetworkingIPAddr &x ) const; + + /// Classify address as FakeIP. This function never returns + /// k_ESteamNetworkingFakeIPType_Invalid. + ESteamNetworkingFakeIPType GetFakeIPType() const; + + /// Return true if we are a FakeIP + bool IsFakeIP() const { return GetFakeIPType() > k_ESteamNetworkingFakeIPType_NotFake; } +}; + +/// An abstract way to represent the identity of a network host. All identities can +/// be represented as simple string. Furthermore, this string representation is actually +/// used on the wire in several places, even though it is less efficient, in order to +/// facilitate forward compatibility. (Old client code can handle an identity type that +/// it doesn't understand.) +struct SteamNetworkingIdentity +{ + /// Type of identity. + ESteamNetworkingIdentityType m_eType; + + // + // Get/Set in various formats. + // + + void Clear(); + bool IsInvalid() const; // Return true if we are the invalid type. Does not make any other validity checks (e.g. is SteamID actually valid) + + void SetSteamID( CSteamID steamID ); + CSteamID GetSteamID() const; // Return black CSteamID (!IsValid()) if identity is not a SteamID + void SetSteamID64( uint64 steamID ); // Takes SteamID as raw 64-bit number + uint64 GetSteamID64() const; // Returns 0 if identity is not SteamID + + bool SetXboxPairwiseID( const char *pszString ); // Returns false if invalid length + const char *GetXboxPairwiseID() const; // Returns nullptr if not Xbox ID + + void SetPSNID( uint64 id ); + uint64 GetPSNID() const; // Returns 0 if not PSN + + void SetStadiaID( uint64 id ); + uint64 GetStadiaID() const; // Returns 0 if not Stadia + + void SetIPAddr( const SteamNetworkingIPAddr &addr ); // Set to specified IP:port + const SteamNetworkingIPAddr *GetIPAddr() const; // returns null if we are not an IP address. + void SetIPv4Addr( uint32 nIPv4, uint16 nPort ); // Set to specified IPv4:port + uint32 GetIPv4() const; // returns 0 if we are not an IPv4 address. + + ESteamNetworkingFakeIPType GetFakeIPType() const; + bool IsFakeIP() const { return GetFakeIPType() > k_ESteamNetworkingFakeIPType_NotFake; } + + // "localhost" is equivalent for many purposes to "anonymous." Our remote + // will identify us by the network address we use. + void SetLocalHost(); // Set to localhost. (We always use IPv6 ::1 for this, not 127.0.0.1) + bool IsLocalHost() const; // Return true if this identity is localhost. + + bool SetGenericString( const char *pszString ); // Returns false if invalid length + const char *GetGenericString() const; // Returns nullptr if not generic string type + + bool SetGenericBytes( const void *data, size_t cbLen ); // Returns false if invalid size. + const uint8 *GetGenericBytes( int &cbLen ) const; // Returns null if not generic bytes type + + /// See if two identities are identical + bool operator==(const SteamNetworkingIdentity &x ) const; + + /// Print to a human-readable string. This is suitable for debug messages + /// or any other time you need to encode the identity as a string. It has a + /// URL-like format (type:). Your buffer should be at least + /// k_cchMaxString bytes big to avoid truncation. + /// + /// See also SteamNetworkingIPAddrRender + void ToString( char *buf, size_t cbBuf ) const; + + /// Parse back a string that was generated using ToString. If we don't understand the + /// string, but it looks "reasonable" (it matches the pattern type: and doesn't + /// have any funky characters, etc), then we will return true, and the type is set to + /// k_ESteamNetworkingIdentityType_UnknownType. false will only be returned if the string + /// looks invalid. + bool ParseString( const char *pszStr ); + + // Max sizes + enum { + k_cchMaxString = 128, // Max length of the buffer needed to hold any identity, formatted in string format by ToString + k_cchMaxGenericString = 32, // Max length of the string for generic string identities. Including terminating '\0' + k_cchMaxXboxPairwiseID = 33, // Including terminating '\0' + k_cbMaxGenericBytes = 32, + }; + + // + // Internal representation. Don't access this directly, use the accessors! + // + // Number of bytes that are relevant below. This MUST ALWAYS be + // set. (Use the accessors!) This is important to enable old code to work + // with new identity types. + int m_cbSize; + union { + uint64 m_steamID64; + uint64 m_PSNID; + uint64 m_stadiaID; + char m_szGenericString[ k_cchMaxGenericString ]; + char m_szXboxPairwiseID[ k_cchMaxXboxPairwiseID ]; + uint8 m_genericBytes[ k_cbMaxGenericBytes ]; + char m_szUnknownRawString[ k_cchMaxString ]; + SteamNetworkingIPAddr m_ip; + uint32 m_reserved[ 32 ]; // Pad structure to leave easy room for future expansion + } data; +}; +#pragma pack(pop) + +// +// Connection status +// + +/// High level connection status +enum ESteamNetworkingConnectionState +{ + + /// Dummy value used to indicate an error condition in the API. + /// Specified connection doesn't exist or has already been closed. + k_ESteamNetworkingConnectionState_None = 0, + + /// We are trying to establish whether peers can talk to each other, + /// whether they WANT to talk to each other, perform basic auth, + /// and exchange crypt keys. + /// + /// - For connections on the "client" side (initiated locally): + /// We're in the process of trying to establish a connection. + /// Depending on the connection type, we might not know who they are. + /// Note that it is not possible to tell if we are waiting on the + /// network to complete handshake packets, or for the application layer + /// to accept the connection. + /// + /// - For connections on the "server" side (accepted through listen socket): + /// We have completed some basic handshake and the client has presented + /// some proof of identity. The connection is ready to be accepted + /// using AcceptConnection(). + /// + /// In either case, any unreliable packets sent now are almost certain + /// to be dropped. Attempts to receive packets are guaranteed to fail. + /// You may send messages if the send mode allows for them to be queued. + /// but if you close the connection before the connection is actually + /// established, any queued messages will be discarded immediately. + /// (We will not attempt to flush the queue and confirm delivery to the + /// remote host, which ordinarily happens when a connection is closed.) + k_ESteamNetworkingConnectionState_Connecting = 1, + + /// Some connection types use a back channel or trusted 3rd party + /// for earliest communication. If the server accepts the connection, + /// then these connections switch into the rendezvous state. During this + /// state, we still have not yet established an end-to-end route (through + /// the relay network), and so if you send any messages unreliable, they + /// are going to be discarded. + k_ESteamNetworkingConnectionState_FindingRoute = 2, + + /// We've received communications from our peer (and we know + /// who they are) and are all good. If you close the connection now, + /// we will make our best effort to flush out any reliable sent data that + /// has not been acknowledged by the peer. (But note that this happens + /// from within the application process, so unlike a TCP connection, you are + /// not totally handing it off to the operating system to deal with it.) + k_ESteamNetworkingConnectionState_Connected = 3, + + /// Connection has been closed by our peer, but not closed locally. + /// The connection still exists from an API perspective. You must close the + /// handle to free up resources. If there are any messages in the inbound queue, + /// you may retrieve them. Otherwise, nothing may be done with the connection + /// except to close it. + /// + /// This stats is similar to CLOSE_WAIT in the TCP state machine. + k_ESteamNetworkingConnectionState_ClosedByPeer = 4, + + /// A disruption in the connection has been detected locally. (E.g. timeout, + /// local internet connection disrupted, etc.) + /// + /// The connection still exists from an API perspective. You must close the + /// handle to free up resources. + /// + /// Attempts to send further messages will fail. Any remaining received messages + /// in the queue are available. + k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 5, + +// +// The following values are used internally and will not be returned by any API. +// We document them here to provide a little insight into the state machine that is used +// under the hood. +// + + /// We've disconnected on our side, and from an API perspective the connection is closed. + /// No more data may be sent or received. All reliable data has been flushed, or else + /// we've given up and discarded it. We do not yet know for sure that the peer knows + /// the connection has been closed, however, so we're just hanging around so that if we do + /// get a packet from them, we can send them the appropriate packets so that they can + /// know why the connection was closed (and not have to rely on a timeout, which makes + /// it appear as if something is wrong). + k_ESteamNetworkingConnectionState_FinWait = -1, + + /// We've disconnected on our side, and from an API perspective the connection is closed. + /// No more data may be sent or received. From a network perspective, however, on the wire, + /// we have not yet given any indication to the peer that the connection is closed. + /// We are in the process of flushing out the last bit of reliable data. Once that is done, + /// we will inform the peer that the connection has been closed, and transition to the + /// FinWait state. + /// + /// Note that no indication is given to the remote host that we have closed the connection, + /// until the data has been flushed. If the remote host attempts to send us data, we will + /// do whatever is necessary to keep the connection alive until it can be closed properly. + /// But in fact the data will be discarded, since there is no way for the application to + /// read it back. Typically this is not a problem, as application protocols that utilize + /// the lingering functionality are designed for the remote host to wait for the response + /// before sending any more data. + k_ESteamNetworkingConnectionState_Linger = -2, + + /// Connection is completely inactive and ready to be destroyed + k_ESteamNetworkingConnectionState_Dead = -3, + + k_ESteamNetworkingConnectionState__Force32Bit = 0x7fffffff +}; + +/// Enumerate various causes of connection termination. These are designed to work similar +/// to HTTP error codes: the numeric range gives you a rough classification as to the source +/// of the problem. +enum ESteamNetConnectionEnd +{ + // Invalid/sentinel value + k_ESteamNetConnectionEnd_Invalid = 0, + + // + // Application codes. These are the values you will pass to + // ISteamNetworkingSockets::CloseConnection. You can use these codes if + // you want to plumb through application-specific reason codes. If you don't + // need this facility, feel free to always pass + // k_ESteamNetConnectionEnd_App_Generic. + // + // The distinction between "normal" and "exceptional" termination is + // one you may use if you find useful, but it's not necessary for you + // to do so. The only place where we distinguish between normal and + // exceptional is in connection analytics. If a significant + // proportion of connections terminates in an exceptional manner, + // this can trigger an alert. + // + + // 1xxx: Application ended the connection in a "usual" manner. + // E.g.: user intentionally disconnected from the server, + // gameplay ended normally, etc + k_ESteamNetConnectionEnd_App_Min = 1000, + k_ESteamNetConnectionEnd_App_Generic = k_ESteamNetConnectionEnd_App_Min, + // Use codes in this range for "normal" disconnection + k_ESteamNetConnectionEnd_App_Max = 1999, + + // 2xxx: Application ended the connection in some sort of exceptional + // or unusual manner that might indicate a bug or configuration + // issue. + // + k_ESteamNetConnectionEnd_AppException_Min = 2000, + k_ESteamNetConnectionEnd_AppException_Generic = k_ESteamNetConnectionEnd_AppException_Min, + // Use codes in this range for "unusual" disconnection + k_ESteamNetConnectionEnd_AppException_Max = 2999, + + // + // System codes. These will be returned by the system when + // the connection state is k_ESteamNetworkingConnectionState_ClosedByPeer + // or k_ESteamNetworkingConnectionState_ProblemDetectedLocally. It is + // illegal to pass a code in this range to ISteamNetworkingSockets::CloseConnection + // + + // 3xxx: Connection failed or ended because of problem with the + // local host or their connection to the Internet. + k_ESteamNetConnectionEnd_Local_Min = 3000, + + // You cannot do what you want to do because you're running in offline mode. + k_ESteamNetConnectionEnd_Local_OfflineMode = 3001, + + // We're having trouble contacting many (perhaps all) relays. + // Since it's unlikely that they all went offline at once, the best + // explanation is that we have a problem on our end. Note that we don't + // bother distinguishing between "many" and "all", because in practice, + // it takes time to detect a connection problem, and by the time + // the connection has timed out, we might not have been able to + // actively probe all of the relay clusters, even if we were able to + // contact them at one time. So this code just means that: + // + // * We don't have any recent successful communication with any relay. + // * We have evidence of recent failures to communicate with multiple relays. + k_ESteamNetConnectionEnd_Local_ManyRelayConnectivity = 3002, + + // A hosted server is having trouble talking to the relay + // that the client was using, so the problem is most likely + // on our end + k_ESteamNetConnectionEnd_Local_HostedServerPrimaryRelay = 3003, + + // We're not able to get the SDR network config. This is + // *almost* always a local issue, since the network config + // comes from the CDN, which is pretty darn reliable. + k_ESteamNetConnectionEnd_Local_NetworkConfig = 3004, + + // Steam rejected our request because we don't have rights + // to do this. + k_ESteamNetConnectionEnd_Local_Rights = 3005, + + // ICE P2P rendezvous failed because we were not able to + // determine our "public" address (e.g. reflexive address via STUN) + // + // If relay fallback is available (it always is on Steam), then + // this is only used internally and will not be returned as a high + // level failure. + k_ESteamNetConnectionEnd_Local_P2P_ICE_NoPublicAddresses = 3006, + + k_ESteamNetConnectionEnd_Local_Max = 3999, + + // 4xxx: Connection failed or ended, and it appears that the + // cause does NOT have to do with the local host or their + // connection to the Internet. It could be caused by the + // remote host, or it could be somewhere in between. + k_ESteamNetConnectionEnd_Remote_Min = 4000, + + // The connection was lost, and as far as we can tell our connection + // to relevant services (relays) has not been disrupted. This doesn't + // mean that the problem is "their fault", it just means that it doesn't + // appear that we are having network issues on our end. + k_ESteamNetConnectionEnd_Remote_Timeout = 4001, + + // Something was invalid with the cert or crypt handshake + // info you gave me, I don't understand or like your key types, + // etc. + k_ESteamNetConnectionEnd_Remote_BadCrypt = 4002, + + // You presented me with a cert that was I was able to parse + // and *technically* we could use encrypted communication. + // But there was a problem that prevents me from checking your identity + // or ensuring that somebody int he middle can't observe our communication. + // E.g.: - the CA key was missing (and I don't accept unsigned certs) + // - The CA key isn't one that I trust, + // - The cert doesn't was appropriately restricted by app, user, time, data center, etc. + // - The cert wasn't issued to you. + // - etc + k_ESteamNetConnectionEnd_Remote_BadCert = 4003, + + // These will never be returned + //k_ESteamNetConnectionEnd_Remote_NotLoggedIn_DEPRECATED = 4004, + //k_ESteamNetConnectionEnd_Remote_NotRunningApp_DEPRECATED = 4005, + + // Something wrong with the protocol version you are using. + // (Probably the code you are running is too old.) + k_ESteamNetConnectionEnd_Remote_BadProtocolVersion = 4006, + + // NAT punch failed failed because we never received any public + // addresses from the remote host. (But we did receive some + // signals form them.) + // + // If relay fallback is available (it always is on Steam), then + // this is only used internally and will not be returned as a high + // level failure. + k_ESteamNetConnectionEnd_Remote_P2P_ICE_NoPublicAddresses = 4007, + + k_ESteamNetConnectionEnd_Remote_Max = 4999, + + // 5xxx: Connection failed for some other reason. + k_ESteamNetConnectionEnd_Misc_Min = 5000, + + // A failure that isn't necessarily the result of a software bug, + // but that should happen rarely enough that it isn't worth specifically + // writing UI or making a localized message for. + // The debug string should contain further details. + k_ESteamNetConnectionEnd_Misc_Generic = 5001, + + // Generic failure that is most likely a software bug. + k_ESteamNetConnectionEnd_Misc_InternalError = 5002, + + // The connection to the remote host timed out, but we + // don't know if the problem is on our end, in the middle, + // or on their end. + k_ESteamNetConnectionEnd_Misc_Timeout = 5003, + + //k_ESteamNetConnectionEnd_Misc_RelayConnectivity_DEPRECATED = 5004, + + // There's some trouble talking to Steam. + k_ESteamNetConnectionEnd_Misc_SteamConnectivity = 5005, + + // A server in a dedicated hosting situation has no relay sessions + // active with which to talk back to a client. (It's the client's + // job to open and maintain those sessions.) + k_ESteamNetConnectionEnd_Misc_NoRelaySessionsToClient = 5006, + + // While trying to initiate a connection, we never received + // *any* communication from the peer. + //k_ESteamNetConnectionEnd_Misc_ServerNeverReplied = 5007, + + // P2P rendezvous failed in a way that we don't have more specific + // information + k_ESteamNetConnectionEnd_Misc_P2P_Rendezvous = 5008, + + // NAT punch failed, probably due to NAT/firewall configuration. + // + // If relay fallback is available (it always is on Steam), then + // this is only used internally and will not be returned as a high + // level failure. + k_ESteamNetConnectionEnd_Misc_P2P_NAT_Firewall = 5009, + + // Our peer replied that it has no record of the connection. + // This should not happen ordinarily, but can happen in a few + // exception cases: + // + // - This is an old connection, and the peer has already cleaned + // up and forgotten about it. (Perhaps it timed out and they + // closed it and were not able to communicate this to us.) + // - A bug or internal protocol error has caused us to try to + // talk to the peer about the connection before we received + // confirmation that the peer has accepted the connection. + // - The peer thinks that we have closed the connection for some + // reason (perhaps a bug), and believes that is it is + // acknowledging our closure. + k_ESteamNetConnectionEnd_Misc_PeerSentNoConnection = 5010, + + k_ESteamNetConnectionEnd_Misc_Max = 5999, + + k_ESteamNetConnectionEnd__Force32Bit = 0x7fffffff +}; + +/// Max length, in bytes (including null terminator) of the reason string +/// when a connection is closed. +const int k_cchSteamNetworkingMaxConnectionCloseReason = 128; + +/// Max length, in bytes (include null terminator) of debug description +/// of a connection. +const int k_cchSteamNetworkingMaxConnectionDescription = 128; + +/// Max length of the app's part of the description +const int k_cchSteamNetworkingMaxConnectionAppName = 32; + +const int k_nSteamNetworkConnectionInfoFlags_Unauthenticated = 1; // We don't have a certificate for the remote host. +const int k_nSteamNetworkConnectionInfoFlags_Unencrypted = 2; // Information is being sent out over a wire unencrypted (by this library) +const int k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers = 4; // Internal loopback buffers. Won't be true for localhost. (You can check the address to determine that.) This implies k_nSteamNetworkConnectionInfoFlags_FastLAN +const int k_nSteamNetworkConnectionInfoFlags_Fast = 8; // The connection is "fast" and "reliable". Either internal/localhost (check the address to find out), or the peer is on the same LAN. (Probably. It's based on the address and the ping time, this is actually hard to determine unambiguously). +const int k_nSteamNetworkConnectionInfoFlags_Relayed = 16; // The connection is relayed somehow (SDR or TURN). +const int k_nSteamNetworkConnectionInfoFlags_DualWifi = 32; // We're taking advantage of dual-wifi multi-path + +/// Describe the state of a connection. +struct SteamNetConnectionInfo_t +{ + + /// Who is on the other end? Depending on the connection type and phase of the connection, we might not know + SteamNetworkingIdentity m_identityRemote; + + /// Arbitrary user data set by the local application code + int64 m_nUserData; + + /// Handle to listen socket this was connected on, or k_HSteamListenSocket_Invalid if we initiated the connection + HSteamListenSocket m_hListenSocket; + + /// Remote address. Might be all 0's if we don't know it, or if this is N/A. + /// (E.g. Basically everything except direct UDP connection.) + SteamNetworkingIPAddr m_addrRemote; + uint16 m__pad1; + + /// What data center is the remote host in? (0 if we don't know.) + SteamNetworkingPOPID m_idPOPRemote; + + /// What relay are we using to communicate with the remote host? + /// (0 if not applicable.) + SteamNetworkingPOPID m_idPOPRelay; + + /// High level state of the connection + ESteamNetworkingConnectionState m_eState; + + /// Basic cause of the connection termination or problem. + /// See ESteamNetConnectionEnd for the values used + int m_eEndReason; + + /// Human-readable, but non-localized explanation for connection + /// termination or problem. This is intended for debugging / + /// diagnostic purposes only, not to display to users. It might + /// have some details specific to the issue. + char m_szEndDebug[ k_cchSteamNetworkingMaxConnectionCloseReason ]; + + /// Debug description. This includes the internal connection ID, + /// connection type (and peer information), and any name + /// given to the connection by the app. This string is used in various + /// internal logging messages. + /// + /// Note that the connection ID *usually* matches the HSteamNetConnection + /// handle, but in certain cases with symmetric connections it might not. + char m_szConnectionDescription[ k_cchSteamNetworkingMaxConnectionDescription ]; + + /// Misc flags. Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx + int m_nFlags; + + /// Internal stuff, room to change API easily + uint32 reserved[63]; +}; + +/// Quick connection state, pared down to something you could call +/// more frequently without it being too big of a perf hit. +struct SteamNetConnectionRealTimeStatus_t +{ + + /// High level state of the connection + ESteamNetworkingConnectionState m_eState; + + /// Current ping (ms) + int m_nPing; + + /// Connection quality measured locally, 0...1. (Percentage of packets delivered + /// end-to-end in order). + float m_flConnectionQualityLocal; + + /// Packet delivery success rate as observed from remote host + float m_flConnectionQualityRemote; + + /// Current data rates from recent history. + float m_flOutPacketsPerSec; + float m_flOutBytesPerSec; + float m_flInPacketsPerSec; + float m_flInBytesPerSec; + + /// Estimate rate that we believe that we can send data to our peer. + /// Note that this could be significantly higher than m_flOutBytesPerSec, + /// meaning the capacity of the channel is higher than you are sending data. + /// (That's OK!) + int m_nSendRateBytesPerSecond; + + /// Number of bytes pending to be sent. This is data that you have recently + /// requested to be sent but has not yet actually been put on the wire. The + /// reliable number ALSO includes data that was previously placed on the wire, + /// but has now been scheduled for re-transmission. Thus, it's possible to + /// observe m_cbPendingReliable increasing between two checks, even if no + /// calls were made to send reliable data between the checks. Data that is + /// awaiting the Nagle delay will appear in these numbers. + int m_cbPendingUnreliable; + int m_cbPendingReliable; + + /// Number of bytes of reliable data that has been placed the wire, but + /// for which we have not yet received an acknowledgment, and thus we may + /// have to re-transmit. + int m_cbSentUnackedReliable; + + /// If you queued a message right now, approximately how long would that message + /// wait in the queue before we actually started putting its data on the wire in + /// a packet? + /// + /// In general, data that is sent by the application is limited by the bandwidth + /// of the channel. If you send data faster than this, it must be queued and + /// put on the wire at a metered rate. Even sending a small amount of data (e.g. + /// a few MTU, say ~3k) will require some of the data to be delayed a bit. + /// + /// Ignoring multiple lanes, the estimated delay will be approximately equal to + /// + /// ( m_cbPendingUnreliable+m_cbPendingReliable ) / m_nSendRateBytesPerSecond + /// + /// plus or minus one MTU. It depends on how much time has elapsed since the last + /// packet was put on the wire. For example, the queue might have *just* been emptied, + /// and the last packet placed on the wire, and we are exactly up against the send + /// rate limit. In that case we might need to wait for one packet's worth of time to + /// elapse before we can send again. On the other extreme, the queue might have data + /// in it waiting for Nagle. (This will always be less than one packet, because as + /// soon as we have a complete packet we would send it.) In that case, we might be + /// ready to send data now, and this value will be 0. + /// + /// This value is only valid if multiple lanes are not used. If multiple lanes are + /// in use, then the queue time will be different for each lane, and you must use + /// the value in SteamNetConnectionRealTimeLaneStatus_t. + /// + /// Nagle delay is ignored for the purposes of this calculation. + SteamNetworkingMicroseconds m_usecQueueTime; + + // Internal stuff, room to change API easily + uint32 reserved[16]; +}; + +/// Quick status of a particular lane +struct SteamNetConnectionRealTimeLaneStatus_t +{ + // Counters for this particular lane. See the corresponding variables + // in SteamNetConnectionRealTimeStatus_t + int m_cbPendingUnreliable; + int m_cbPendingReliable; + int m_cbSentUnackedReliable; + int _reservePad1; // Reserved for future use + + /// Lane-specific queue time. This value takes into consideration lane priorities + /// and weights, and how much data is queued in each lane, and attempts to predict + /// how any data currently queued will be sent out. + SteamNetworkingMicroseconds m_usecQueueTime; + + // Internal stuff, room to change API easily + uint32 reserved[10]; +}; + +#pragma pack( pop ) + +// +// Network messages +// + +/// Max size of a single message that we can SEND. +/// Note: We might be wiling to receive larger messages, +/// and our peer might, too. +const int k_cbMaxSteamNetworkingSocketsMessageSizeSend = 512 * 1024; + +/// A message that has been received. +struct SteamNetworkingMessage_t +{ + + /// Message payload + void *m_pData; + + /// Size of the payload. + int m_cbSize; + + /// For messages received on connections: what connection did this come from? + /// For outgoing messages: what connection to send it to? + /// Not used when using the ISteamNetworkingMessages interface + HSteamNetConnection m_conn; + + /// For inbound messages: Who sent this to us? + /// For outbound messages on connections: not used. + /// For outbound messages on the ad-hoc ISteamNetworkingMessages interface: who should we send this to? + SteamNetworkingIdentity m_identityPeer; + + /// For messages received on connections, this is the user data + /// associated with the connection. + /// + /// This is *usually* the same as calling GetConnection() and then + /// fetching the user data associated with that connection, but for + /// the following subtle differences: + /// + /// - This user data will match the connection's user data at the time + /// is captured at the time the message is returned by the API. + /// If you subsequently change the userdata on the connection, + /// this won't be updated. + /// - This is an inline call, so it's *much* faster. + /// - You might have closed the connection, so fetching the user data + /// would not be possible. + /// + /// Not used when sending messages. + int64 m_nConnUserData; + + /// Local timestamp when the message was received + /// Not used for outbound messages. + SteamNetworkingMicroseconds m_usecTimeReceived; + + /// Message number assigned by the sender. This is not used for outbound + /// messages. Note that if multiple lanes are used, each lane has its own + /// message numbers, which are assigned sequentially, so messages from + /// different lanes will share the same numbers. + int64 m_nMessageNumber; + + /// Function used to free up m_pData. This mechanism exists so that + /// apps can create messages with buffers allocated from their own + /// heap, and pass them into the library. This function will + /// usually be something like: + /// + /// free( pMsg->m_pData ); + void (*m_pfnFreeData)( SteamNetworkingMessage_t *pMsg ); + + /// Function to used to decrement the internal reference count and, if + /// it's zero, release the message. You should not set this function pointer, + /// or need to access this directly! Use the Release() function instead! + void (*m_pfnRelease)( SteamNetworkingMessage_t *pMsg ); + + /// When using ISteamNetworkingMessages, the channel number the message was received on + /// (Not used for messages sent or received on "connections") + int m_nChannel; + + /// Bitmask of k_nSteamNetworkingSend_xxx flags. + /// For received messages, only the k_nSteamNetworkingSend_Reliable bit is valid. + /// For outbound messages, all bits are relevant + int m_nFlags; + + /// Arbitrary user data that you can use when sending messages using + /// ISteamNetworkingUtils::AllocateMessage and ISteamNetworkingSockets::SendMessage. + /// (The callback you set in m_pfnFreeData might use this field.) + /// + /// Not used for received messages. + int64 m_nUserData; + + /// For outbound messages, which lane to use? See ISteamNetworkingSockets::ConfigureConnectionLanes. + /// For inbound messages, what lane was the message received on? + uint16 m_idxLane; + uint16 _pad1__; + + /// You MUST call this when you're done with the object, + /// to free up memory, etc. + inline void Release(); + + // For code compatibility, some accessors +#ifndef API_GEN + inline uint32 GetSize() const { return m_cbSize; } + inline const void *GetData() const { return m_pData; } + inline int GetChannel() const { return m_nChannel; } + inline HSteamNetConnection GetConnection() const { return m_conn; } + inline int64 GetConnectionUserData() const { return m_nConnUserData; } + inline SteamNetworkingMicroseconds GetTimeReceived() const { return m_usecTimeReceived; } + inline int64 GetMessageNumber() const { return m_nMessageNumber; } +#endif +protected: + // Declare destructor protected. You should never need to declare a message + // object on the stack or create one yourself. + // - You will receive a pointer to a message object when you receive messages (e.g. ISteamNetworkingSockets::ReceiveMessagesOnConnection) + // - You can allocate a message object for efficient sending using ISteamNetworkingUtils::AllocateMessage + // - Call Release() to free the object + inline ~SteamNetworkingMessage_t() {} +}; + +// +// Flags used to set options for message sending +// + +// Send the message unreliably. Can be lost. Messages *can* be larger than a +// single MTU (UDP packet), but there is no retransmission, so if any piece +// of the message is lost, the entire message will be dropped. +// +// The sending API does have some knowledge of the underlying connection, so +// if there is no NAT-traversal accomplished or there is a recognized adjustment +// happening on the connection, the packet will be batched until the connection +// is open again. +// +// Migration note: This is not exactly the same as k_EP2PSendUnreliable! You +// probably want k_ESteamNetworkingSendType_UnreliableNoNagle +const int k_nSteamNetworkingSend_Unreliable = 0; + +// Disable Nagle's algorithm. +// By default, Nagle's algorithm is applied to all outbound messages. This means +// that the message will NOT be sent immediately, in case further messages are +// sent soon after you send this, which can be grouped together. Any time there +// is enough buffered data to fill a packet, the packets will be pushed out immediately, +// but partially-full packets not be sent until the Nagle timer expires. See +// ISteamNetworkingSockets::FlushMessagesOnConnection, ISteamNetworkingMessages::FlushMessagesToUser +// +// NOTE: Don't just send every message without Nagle because you want packets to get there +// quicker. Make sure you understand the problem that Nagle is solving before disabling it. +// If you are sending small messages, often many at the same time, then it is very likely that +// it will be more efficient to leave Nagle enabled. A typical proper use of this flag is +// when you are sending what you know will be the last message sent for a while (e.g. the last +// in the server simulation tick to a particular client), and you use this flag to flush all +// messages. +const int k_nSteamNetworkingSend_NoNagle = 1; + +// Send a message unreliably, bypassing Nagle's algorithm for this message and any messages +// currently pending on the Nagle timer. This is equivalent to using k_ESteamNetworkingSend_Unreliable +// and then immediately flushing the messages using ISteamNetworkingSockets::FlushMessagesOnConnection +// or ISteamNetworkingMessages::FlushMessagesToUser. (But using this flag is more efficient since you +// only make one API call.) +const int k_nSteamNetworkingSend_UnreliableNoNagle = k_nSteamNetworkingSend_Unreliable|k_nSteamNetworkingSend_NoNagle; + +// If the message cannot be sent very soon (because the connection is still doing some initial +// handshaking, route negotiations, etc), then just drop it. This is only applicable for unreliable +// messages. Using this flag on reliable messages is invalid. +const int k_nSteamNetworkingSend_NoDelay = 4; + +// Send an unreliable message, but if it cannot be sent relatively quickly, just drop it instead of queuing it. +// This is useful for messages that are not useful if they are excessively delayed, such as voice data. +// NOTE: The Nagle algorithm is not used, and if the message is not dropped, any messages waiting on the +// Nagle timer are immediately flushed. +// +// A message will be dropped under the following circumstances: +// - the connection is not fully connected. (E.g. the "Connecting" or "FindingRoute" states) +// - there is a sufficiently large number of messages queued up already such that the current message +// will not be placed on the wire in the next ~200ms or so. +// +// If a message is dropped for these reasons, k_EResultIgnored will be returned. +const int k_nSteamNetworkingSend_UnreliableNoDelay = k_nSteamNetworkingSend_Unreliable|k_nSteamNetworkingSend_NoDelay|k_nSteamNetworkingSend_NoNagle; + +// Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message. +// Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for +// efficient sends of large chunks of data. +// +// The Nagle algorithm is used. See notes on k_ESteamNetworkingSendType_Unreliable for more details. +// See k_ESteamNetworkingSendType_ReliableNoNagle, ISteamNetworkingSockets::FlushMessagesOnConnection, +// ISteamNetworkingMessages::FlushMessagesToUser +// +// Migration note: This is NOT the same as k_EP2PSendReliable, it's more like k_EP2PSendReliableWithBuffering +const int k_nSteamNetworkingSend_Reliable = 8; + +// Send a message reliably, but bypass Nagle's algorithm. +// +// Migration note: This is equivalent to k_EP2PSendReliable +const int k_nSteamNetworkingSend_ReliableNoNagle = k_nSteamNetworkingSend_Reliable|k_nSteamNetworkingSend_NoNagle; + +// By default, message sending is queued, and the work of encryption and talking to +// the operating system sockets, etc is done on a service thread. This is usually a +// a performance win when messages are sent from the "main thread". However, if this +// flag is set, and data is ready to be sent immediately (either from this message +// or earlier queued data), then that work will be done in the current thread, before +// the current call returns. If data is not ready to be sent (due to rate limiting +// or Nagle), then this flag has no effect. +// +// This is an advanced flag used to control performance at a very low level. For +// most applications running on modern hardware with more than one CPU core, doing +// the work of sending on a service thread will yield the best performance. Only +// use this flag if you have a really good reason and understand what you are doing. +// Otherwise you will probably just make performance worse. +const int k_nSteamNetworkingSend_UseCurrentThread = 16; + +// When sending a message using ISteamNetworkingMessages, automatically re-establish +// a broken session, without returning k_EResultNoConnection. Without this flag, +// if you attempt to send a message, and the session was proactively closed by the +// peer, or an error occurred that disrupted communications, then you must close the +// session using ISteamNetworkingMessages::CloseSessionWithUser before attempting to +// send another message. (Or you can simply add this flag and retry.) In this way, +// the disruption cannot go unnoticed, and a more clear order of events can be +// ascertained. This is especially important when reliable messages are used, since +// if the connection is disrupted, some of those messages will not have been delivered, +// and it is in general not possible to know which. Although a +// SteamNetworkingMessagesSessionFailed_t callback will be posted when an error occurs +// to notify you that a failure has happened, callbacks are asynchronous, so it is not +// possible to tell exactly when it happened. And because the primary purpose of +// ISteamNetworkingMessages is to be like UDP, there is no notification when a peer closes +// the session. +// +// If you are not using any reliable messages (e.g. you are using ISteamNetworkingMessages +// exactly as a transport replacement for UDP-style datagrams only), you may not need to +// know when an underlying connection fails, and so you may not need this notification. +const int k_nSteamNetworkingSend_AutoRestartBrokenSession = 32; + +// +// Ping location / measurement +// + +/// Object that describes a "location" on the Internet with sufficient +/// detail that we can reasonably estimate an upper bound on the ping between +/// the two hosts, even if a direct route between the hosts is not possible, +/// and the connection must be routed through the Steam Datagram Relay network. +/// This does not contain any information that identifies the host. Indeed, +/// if two hosts are in the same building or otherwise have nearly identical +/// networking characteristics, then it's valid to use the same location +/// object for both of them. +/// +/// NOTE: This object should only be used in the same process! Do not serialize it, +/// send it over the wire, or persist it in a file or database! If you need +/// to do that, convert it to a string representation using the methods in +/// ISteamNetworkingUtils(). +struct SteamNetworkPingLocation_t +{ + uint8 m_data[ 512 ]; +}; + +/// Max possible length of a ping location, in string format. This is +/// an extremely conservative worst case value which leaves room for future +/// syntax enhancements. Most strings in practice are a lot shorter. +/// If you are storing many of these, you will very likely benefit from +/// using dynamic memory. +const int k_cchMaxSteamNetworkingPingLocationString = 1024; + +/// Special values that are returned by some functions that return a ping. +const int k_nSteamNetworkingPing_Failed = -1; +const int k_nSteamNetworkingPing_Unknown = -2; + +// +// Configuration values +// + +/// Configuration values can be applied to different types of objects. +enum ESteamNetworkingConfigScope +{ + + /// Get/set global option, or defaults. Even options that apply to more specific scopes + /// have global scope, and you may be able to just change the global defaults. If you + /// need different settings per connection (for example), then you will need to set those + /// options at the more specific scope. + k_ESteamNetworkingConfig_Global = 1, + + /// Some options are specific to a particular interface. Note that all connection + /// and listen socket settings can also be set at the interface level, and they will + /// apply to objects created through those interfaces. + k_ESteamNetworkingConfig_SocketsInterface = 2, + + /// Options for a listen socket. Listen socket options can be set at the interface layer, + /// if you have multiple listen sockets and they all use the same options. + /// You can also set connection options on a listen socket, and they set the defaults + /// for all connections accepted through this listen socket. (They will be used if you don't + /// set a connection option.) + k_ESteamNetworkingConfig_ListenSocket = 3, + + /// Options for a specific connection. + k_ESteamNetworkingConfig_Connection = 4, + + k_ESteamNetworkingConfigScope__Force32Bit = 0x7fffffff +}; + +// Different configuration values have different data types +enum ESteamNetworkingConfigDataType +{ + k_ESteamNetworkingConfig_Int32 = 1, + k_ESteamNetworkingConfig_Int64 = 2, + k_ESteamNetworkingConfig_Float = 3, + k_ESteamNetworkingConfig_String = 4, + k_ESteamNetworkingConfig_Ptr = 5, + + k_ESteamNetworkingConfigDataType__Force32Bit = 0x7fffffff +}; + +/// Configuration options +enum ESteamNetworkingConfigValue +{ + k_ESteamNetworkingConfig_Invalid = 0, + +// +// Connection options +// + + /// [connection int32] Timeout value (in ms) to use when first connecting + k_ESteamNetworkingConfig_TimeoutInitial = 24, + + /// [connection int32] Timeout value (in ms) to use after connection is established + k_ESteamNetworkingConfig_TimeoutConnected = 25, + + /// [connection int32] Upper limit of buffered pending bytes to be sent, + /// if this is reached SendMessage will return k_EResultLimitExceeded + /// Default is 512k (524288 bytes) + k_ESteamNetworkingConfig_SendBufferSize = 9, + + /// [connection int32] Upper limit on total size (in bytes) of received messages + /// that will be buffered waiting to be processed by the application. If this limit + /// is exceeded, packets will be dropped. This is to protect us from a malicious + /// peer flooding us with messages faster than we can process them. + /// + /// This must be bigger than k_ESteamNetworkingConfig_RecvMaxMessageSize + k_ESteamNetworkingConfig_RecvBufferSize = 47, + + /// [connection int32] Upper limit on the number of received messages that will + /// that will be buffered waiting to be processed by the application. If this limit + /// is exceeded, packets will be dropped. This is to protect us from a malicious + /// peer flooding us with messages faster than we can pull them off the wire. + k_ESteamNetworkingConfig_RecvBufferMessages = 48, + + /// [connection int32] Maximum message size that we are willing to receive. + /// if a client attempts to send us a message larger than this, the connection + /// will be immediately closed. + /// + /// Default is 512k (524288 bytes). Note that the peer needs to be able to + /// send a message this big. (See k_cbMaxSteamNetworkingSocketsMessageSizeSend.) + k_ESteamNetworkingConfig_RecvMaxMessageSize = 49, + + /// [connection int32] Max number of message segments that can be received + /// in a single UDP packet. While decoding a packet, if the number of segments + /// exceeds this, we will abort further packet processing. + /// + /// The default is effectively unlimited. If you know that you very rarely + /// send small packets, you can protect yourself from malicious senders by + /// lowering this number. + /// + /// In particular, if you are NOT using the reliability layer and are only using + /// SteamNetworkingSockets for datagram transport, setting this to a very low + /// number may be beneficial. (We recommend a value of 2.) Make sure your sender + /// disables Nagle! + k_ESteamNetworkingConfig_RecvMaxSegmentsPerPacket = 50, + + /// [connection int64] Get/set userdata as a configuration option. + /// The default value is -1. You may want to set the user data as + /// a config value, instead of using ISteamNetworkingSockets::SetConnectionUserData + /// in two specific instances: + /// + /// - You wish to set the userdata atomically when creating + /// an outbound connection, so that the userdata is filled in properly + /// for any callbacks that happen. However, note that this trick + /// only works for connections initiated locally! For incoming + /// connections, multiple state transitions may happen and + /// callbacks be queued, before you are able to service the first + /// callback! Be careful! + /// + /// - You can set the default userdata for all newly created connections + /// by setting this value at a higher level (e.g. on the listen + /// socket or at the global level.) Then this default + /// value will be inherited when the connection is created. + /// This is useful in case -1 is a valid userdata value, and you + /// wish to use something else as the default value so you can + /// tell if it has been set or not. + /// + /// HOWEVER: once a connection is created, the effective value is + /// then bound to the connection. Unlike other connection options, + /// if you change it again at a higher level, the new value will not + /// be inherited by connections. + /// + /// Using the userdata field in callback structs is not advised because + /// of tricky race conditions. Instead, you might try one of these methods: + /// + /// - Use a separate map with the HSteamNetConnection as the key. + /// - Fetch the userdata from the connection in your callback + /// using ISteamNetworkingSockets::GetConnectionUserData, to + // ensure you have the current value. + k_ESteamNetworkingConfig_ConnectionUserData = 40, + + /// [connection int32] Minimum/maximum send rate clamp, in bytes/sec. + /// At the time of this writing these two options should always be set to + /// the same value, to manually configure a specific send rate. The default + /// value is 256K. Eventually we hope to have the library estimate the bandwidth + /// of the channel and set the send rate to that estimated bandwidth, and these + /// values will only set limits on that send rate. + k_ESteamNetworkingConfig_SendRateMin = 10, + k_ESteamNetworkingConfig_SendRateMax = 11, + + /// [connection int32] Nagle time, in microseconds. When SendMessage is called, if + /// the outgoing message is less than the size of the MTU, it will be + /// queued for a delay equal to the Nagle timer value. This is to ensure + /// that if the application sends several small messages rapidly, they are + /// coalesced into a single packet. + /// See historical RFC 896. Value is in microseconds. + /// Default is 5000us (5ms). + k_ESteamNetworkingConfig_NagleTime = 12, + + /// [connection int32] Don't automatically fail IP connections that don't have + /// strong auth. On clients, this means we will attempt the connection even if + /// we don't know our identity or can't get a cert. On the server, it means that + /// we won't automatically reject a connection due to a failure to authenticate. + /// (You can examine the incoming connection and decide whether to accept it.) + /// + /// 0: Don't attempt or accept unauthorized connections + /// 1: Attempt authorization when connecting, and allow unauthorized peers, but emit warnings + /// 2: don't attempt authentication, or complain if peer is unauthenticated + /// + /// This is a dev configuration value, and you should not let users modify it in + /// production. + k_ESteamNetworkingConfig_IP_AllowWithoutAuth = 23, + + /// [connection int32] The same as IP_AllowWithoutAuth, but will only apply + /// for connections to/from localhost addresses. Whichever value is larger + /// (more permissive) will be used. + k_ESteamNetworkingConfig_IPLocalHost_AllowWithoutAuth = 52, + + /// [connection int32] Do not send UDP packets with a payload of + /// larger than N bytes. If you set this, k_ESteamNetworkingConfig_MTU_DataSize + /// is automatically adjusted + k_ESteamNetworkingConfig_MTU_PacketSize = 32, + + /// [connection int32] (read only) Maximum message size you can send that + /// will not fragment, based on k_ESteamNetworkingConfig_MTU_PacketSize + k_ESteamNetworkingConfig_MTU_DataSize = 33, + + /// [connection int32] Allow unencrypted (and unauthenticated) communication. + /// 0: Not allowed (the default) + /// 1: Allowed, but prefer encrypted + /// 2: Allowed, and preferred + /// 3: Required. (Fail the connection if the peer requires encryption.) + /// + /// This is a dev configuration value, since its purpose is to disable encryption. + /// You should not let users modify it in production. (But note that it requires + /// the peer to also modify their value in order for encryption to be disabled.) + k_ESteamNetworkingConfig_Unencrypted = 34, + + /// [connection int32] Set this to 1 on outbound connections and listen sockets, + /// to enable "symmetric connect mode", which is useful in the following + /// common peer-to-peer use case: + /// + /// - The two peers are "equal" to each other. (Neither is clearly the "client" + /// or "server".) + /// - Either peer may initiate the connection, and indeed they may do this + /// at the same time + /// - The peers only desire a single connection to each other, and if both + /// peers initiate connections simultaneously, a protocol is needed for them + /// to resolve the conflict, so that we end up with a single connection. + /// + /// This use case is both common, and involves subtle race conditions and tricky + /// pitfalls, which is why the API has support for dealing with it. + /// + /// If an incoming connection arrives on a listen socket or via custom signaling, + /// and the application has not attempted to make a matching outbound connection + /// in symmetric mode, then the incoming connection can be accepted as usual. + /// A "matching" connection means that the relevant endpoint information matches. + /// (At the time this comment is being written, this is only supported for P2P + /// connections, which means that the peer identities must match, and the virtual + /// port must match. At a later time, symmetric mode may be supported for other + /// connection types.) + /// + /// If connections are initiated by both peers simultaneously, race conditions + /// can arise, but fortunately, most of them are handled internally and do not + /// require any special awareness from the application. However, there + /// is one important case that application code must be aware of: + /// If application code attempts an outbound connection using a ConnectXxx + /// function in symmetric mode, and a matching incoming connection is already + /// waiting on a listen socket, then instead of forming a new connection, + /// the ConnectXxx call will accept the existing incoming connection, and return + /// a connection handle to this accepted connection. + /// IMPORTANT: in this case, a SteamNetConnectionStatusChangedCallback_t + /// has probably *already* been posted to the queue for the incoming connection! + /// (Once callbacks are posted to the queue, they are not modified.) It doesn't + /// matter if the callback has not been consumed by the app. Thus, application + /// code that makes use of symmetric connections must be aware that, when processing a + /// SteamNetConnectionStatusChangedCallback_t for an incoming connection, the + /// m_hConn may refer to a new connection that the app has has not + /// seen before (the usual case), but it may also refer to a connection that + /// has already been accepted implicitly through a call to Connect()! In this + /// case, AcceptConnection() will return k_EResultDuplicateRequest. + /// + /// Only one symmetric connection to a given peer (on a given virtual port) + /// may exist at any given time. If client code attempts to create a connection, + /// and a (live) connection already exists on the local host, then either the + /// existing connection will be accepted as described above, or the attempt + /// to create a new connection will fail. Furthermore, linger mode functionality + /// is not supported on symmetric connections. + /// + /// A more complicated race condition can arise if both peers initiate a connection + /// at roughly the same time. In this situation, each peer will receive an incoming + /// connection from the other peer, when the application code has already initiated + /// an outgoing connection to that peer. The peers must resolve this conflict and + /// decide who is going to act as the "server" and who will act as the "client". + /// Typically the application does not need to be aware of this case as it is handled + /// internally. On both sides, the will observe their outbound connection being + /// "accepted", although one of them one have been converted internally to act + /// as the "server". + /// + /// In general, symmetric mode should be all-or-nothing: do not mix symmetric + /// connections with a non-symmetric connection that it might possible "match" + /// with. If you use symmetric mode on any connections, then both peers should + /// use it on all connections, and the corresponding listen socket, if any. The + /// behaviour when symmetric and ordinary connections are mixed is not defined by + /// this API, and you should not rely on it. (This advice only applies when connections + /// might possibly "match". For example, it's OK to use all symmetric mode + /// connections on one virtual port, and all ordinary, non-symmetric connections + /// on a different virtual port, as there is no potential for ambiguity.) + /// + /// When using the feature, you should set it in the following situations on + /// applicable objects: + /// + /// - When creating an outbound connection using ConnectXxx function + /// - When creating a listen socket. (Note that this will automatically cause + /// any accepted connections to inherit the flag.) + /// - When using custom signaling, before accepting an incoming connection. + /// + /// Setting the flag on listen socket and accepted connections will enable the + /// API to automatically deal with duplicate incoming connections, even if the + /// local host has not made any outbound requests. (In general, such duplicate + /// requests from a peer are ignored internally and will not be visible to the + /// application code. The previous connection must be closed or resolved first.) + k_ESteamNetworkingConfig_SymmetricConnect = 37, + + /// [connection int32] For connection types that use "virtual ports", this can be used + /// to assign a local virtual port. For incoming connections, this will always be the + /// virtual port of the listen socket (or the port requested by the remote host if custom + /// signaling is used and the connection is accepted), and cannot be changed. For + /// connections initiated locally, the local virtual port will default to the same as the + /// requested remote virtual port, if you do not specify a different option when creating + /// the connection. The local port is only relevant for symmetric connections, when + /// determining if two connections "match." In this case, if you need the local and remote + /// port to differ, you can set this value. + /// + /// You can also read back this value on listen sockets. + /// + /// This value should not be read or written in any other context. + k_ESteamNetworkingConfig_LocalVirtualPort = 38, + + /// [connection int32] Enable Dual wifi band support for this connection + /// 0 = no, 1 = yes, 2 = simulate it for debugging, even if dual wifi not available + k_ESteamNetworkingConfig_DualWifi_Enable = 39, + + /// [connection int32] True to enable diagnostics reporting through + /// generic platform UI. (Only available on Steam.) + k_ESteamNetworkingConfig_EnableDiagnosticsUI = 46, + +// +// Simulating network conditions +// +// These are global (not per-connection) because they apply at +// a relatively low UDP layer. +// + + /// [global float, 0--100] Randomly discard N pct of packets instead of sending/recv + /// This is a global option only, since it is applied at a low level + /// where we don't have much context + k_ESteamNetworkingConfig_FakePacketLoss_Send = 2, + k_ESteamNetworkingConfig_FakePacketLoss_Recv = 3, + + /// [global int32]. Delay all outbound/inbound packets by N ms + k_ESteamNetworkingConfig_FakePacketLag_Send = 4, + k_ESteamNetworkingConfig_FakePacketLag_Recv = 5, + + /// [global float] 0-100 Percentage of packets we will add additional delay + /// to (causing them to be reordered) + k_ESteamNetworkingConfig_FakePacketReorder_Send = 6, + k_ESteamNetworkingConfig_FakePacketReorder_Recv = 7, + + /// [global int32] Extra delay, in ms, to apply to reordered packets. + k_ESteamNetworkingConfig_FakePacketReorder_Time = 8, + + /// [global float 0--100] Globally duplicate some percentage of packets we send + k_ESteamNetworkingConfig_FakePacketDup_Send = 26, + k_ESteamNetworkingConfig_FakePacketDup_Recv = 27, + + /// [global int32] Amount of delay, in ms, to delay duplicated packets. + /// (We chose a random delay between 0 and this value) + k_ESteamNetworkingConfig_FakePacketDup_TimeMax = 28, + + /// [global int32] Trace every UDP packet, similar to Wireshark or tcpdump. + /// Value is max number of bytes to dump. -1 disables tracing. + // 0 only traces the info but no actual data bytes + k_ESteamNetworkingConfig_PacketTraceMaxBytes = 41, + + + // [global int32] Global UDP token bucket rate limits. + // "Rate" refers to the steady state rate. (Bytes/sec, the + // rate that tokens are put into the bucket.) "Burst" + // refers to the max amount that could be sent in a single + // burst. (In bytes, the max capacity of the bucket.) + // Rate=0 disables the limiter entirely, which is the default. + // Burst=0 disables burst. (This is not realistic. A + // burst of at least 4K is recommended; the default is higher.) + k_ESteamNetworkingConfig_FakeRateLimit_Send_Rate = 42, + k_ESteamNetworkingConfig_FakeRateLimit_Send_Burst = 43, + k_ESteamNetworkingConfig_FakeRateLimit_Recv_Rate = 44, + k_ESteamNetworkingConfig_FakeRateLimit_Recv_Burst = 45, + + // Timeout used for out-of-order correction. This is used when we see a small + // gap in the sequence number on a packet flow. For example let's say we are + // processing packet 105 when the most recent one was 103. 104 might have dropped, + // but there is also a chance that packets are simply being reordered. It is very + // common on certain types of connections for packet 104 to arrive very soon after 105, + // especially if 104 was large and 104 was small. In this case, when we see packet 105 + // we will shunt it aside and pend it, in the hopes of seeing 104 soon after. If 104 + // arrives before the a timeout occurs, then we can deliver the packets in order to the + // remainder of packet processing, and we will record this as a "correctable" out-of-order + // situation. If the timer expires, then we will process packet 105, and assume for now + // that 104 has dropped. (If 104 later arrives, we will process it, but that will be + // accounted for as uncorrected.) + // + // The default value is 1000 microseconds. Note that the Windows scheduler does not + // have microsecond precision. + // + // Set the value to 0 to disable out of order correction at the packet layer. + // In many cases we are still effectively able to correct the situation because + // reassembly of message fragments is tolerant of fragments packets arriving out of + // order. Also, when messages are decoded and inserted into the queue for the app + // to receive them, we will correct out of order messages that have not been + // dequeued by the app yet. However, when out-of-order packets are corrected + // at the packet layer, they will not reduce the connection quality measure. + // (E.g. SteamNetConnectionRealTimeStatus_t::m_flConnectionQualityLocal) + k_ESteamNetworkingConfig_OutOfOrderCorrectionWindowMicroseconds = 51, + +// +// Callbacks +// + + // On Steam, you may use the default Steam callback dispatch mechanism. If you prefer + // to not use this dispatch mechanism (or you are not running with Steam), or you want + // to associate specific functions with specific listen sockets or connections, you can + // register them as configuration values. + // + // Note also that ISteamNetworkingUtils has some helpers to set these globally. + + /// [connection FnSteamNetConnectionStatusChanged] Callback that will be invoked + /// when the state of a connection changes. + /// + /// IMPORTANT: callbacks are dispatched to the handler that is in effect at the time + /// the event occurs, which might be in another thread. For example, immediately after + /// creating a listen socket, you may receive an incoming connection. And then immediately + /// after this, the remote host may close the connection. All of this could happen + /// before the function to create the listen socket has returned. For this reason, + /// callbacks usually must be in effect at the time of object creation. This means + /// you should set them when you are creating the listen socket or connection, or have + /// them in effect so they will be inherited at the time of object creation. + /// + /// For example: + /// + /// exterm void MyStatusChangedFunc( SteamNetConnectionStatusChangedCallback_t *info ); + /// SteamNetworkingConfigValue_t opt; opt.SetPtr( k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, MyStatusChangedFunc ); + /// SteamNetworkingIPAddr localAddress; localAddress.Clear(); + /// HSteamListenSocket hListenSock = SteamNetworkingSockets()->CreateListenSocketIP( localAddress, 1, &opt ); + /// + /// When accepting an incoming connection, there is no atomic way to switch the + /// callback. However, if the connection is DOA, AcceptConnection() will fail, and + /// you can fetch the state of the connection at that time. + /// + /// If all connections and listen sockets can use the same callback, the simplest + /// method is to set it globally before you create any listen sockets or connections. + k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged = 201, + + /// [global FnSteamNetAuthenticationStatusChanged] Callback that will be invoked + /// when our auth state changes. If you use this, install the callback before creating + /// any connections or listen sockets, and don't change it. + /// See: ISteamNetworkingUtils::SetGlobalCallback_SteamNetAuthenticationStatusChanged + k_ESteamNetworkingConfig_Callback_AuthStatusChanged = 202, + + /// [global FnSteamRelayNetworkStatusChanged] Callback that will be invoked + /// when our auth state changes. If you use this, install the callback before creating + /// any connections or listen sockets, and don't change it. + /// See: ISteamNetworkingUtils::SetGlobalCallback_SteamRelayNetworkStatusChanged + k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged = 203, + + /// [global FnSteamNetworkingMessagesSessionRequest] Callback that will be invoked + /// when a peer wants to initiate a SteamNetworkingMessagesSessionRequest. + /// See: ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionRequest + k_ESteamNetworkingConfig_Callback_MessagesSessionRequest = 204, + + /// [global FnSteamNetworkingMessagesSessionFailed] Callback that will be invoked + /// when a session you have initiated, or accepted either fails to connect, or loses + /// connection in some unexpected way. + /// See: ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionFailed + k_ESteamNetworkingConfig_Callback_MessagesSessionFailed = 205, + + /// [global FnSteamNetworkingSocketsCreateConnectionSignaling] Callback that will + /// be invoked when we need to create a signaling object for a connection + /// initiated locally. See: ISteamNetworkingSockets::ConnectP2P, + /// ISteamNetworkingMessages. + k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling = 206, + + /// [global FnSteamNetworkingFakeIPResult] Callback that's invoked when + /// a FakeIP allocation finishes. See: ISteamNetworkingSockets::BeginAsyncRequestFakeIP, + /// ISteamNetworkingUtils::SetGlobalCallback_FakeIPResult + k_ESteamNetworkingConfig_Callback_FakeIPResult = 207, + +// +// P2P connection settings +// + +// /// [listen socket int32] When you create a P2P listen socket, we will automatically +// /// open up a UDP port to listen for LAN connections. LAN connections can be made +// /// without any signaling: both sides can be disconnected from the Internet. +// /// +// /// This value can be set to zero to disable the feature. +// k_ESteamNetworkingConfig_P2P_Discovery_Server_LocalPort = 101, +// +// /// [connection int32] P2P connections can perform broadcasts looking for the peer +// /// on the LAN. +// k_ESteamNetworkingConfig_P2P_Discovery_Client_RemotePort = 102, + + /// [connection string] Comma-separated list of STUN servers that can be used + /// for NAT piercing. If you set this to an empty string, NAT piercing will + /// not be attempted. Also if "public" candidates are not allowed for + /// P2P_Transport_ICE_Enable, then this is ignored. + k_ESteamNetworkingConfig_P2P_STUN_ServerList = 103, + + /// [connection int32] What types of ICE candidates to share with the peer. + /// See k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_xxx values + k_ESteamNetworkingConfig_P2P_Transport_ICE_Enable = 104, + + /// [connection int32] When selecting P2P transport, add various + /// penalties to the scores for selected transports. (Route selection + /// scores are on a scale of milliseconds. The score begins with the + /// route ping time and is then adjusted.) + k_ESteamNetworkingConfig_P2P_Transport_ICE_Penalty = 105, + k_ESteamNetworkingConfig_P2P_Transport_SDR_Penalty = 106, + k_ESteamNetworkingConfig_P2P_TURN_ServerList = 107, + k_ESteamNetworkingConfig_P2P_TURN_UserList = 108, + k_ESteamNetworkingConfig_P2P_TURN_PassList = 109, + //k_ESteamNetworkingConfig_P2P_Transport_LANBeacon_Penalty = 107, + k_ESteamNetworkingConfig_P2P_Transport_ICE_Implementation = 110, + +// +// Settings for SDR relayed connections +// + + /// [global int32] If the first N pings to a port all fail, mark that port as unavailable for + /// a while, and try a different one. Some ISPs and routers may drop the first + /// packet, so setting this to 1 may greatly disrupt communications. + k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFailInitial = 19, + + /// [global int32] If N consecutive pings to a port fail, after having received successful + /// communication, mark that port as unavailable for a while, and try a + /// different one. + k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFail = 20, + + /// [global int32] Minimum number of lifetime pings we need to send, before we think our estimate + /// is solid. The first ping to each cluster is very often delayed because of NAT, + /// routers not having the best route, etc. Until we've sent a sufficient number + /// of pings, our estimate is often inaccurate. Keep pinging until we get this + /// many pings. + k_ESteamNetworkingConfig_SDRClient_MinPingsBeforePingAccurate = 21, + + /// [global int32] Set all steam datagram traffic to originate from the same + /// local port. By default, we open up a new UDP socket (on a different local + /// port) for each relay. This is slightly less optimal, but it works around + /// some routers that don't implement NAT properly. If you have intermittent + /// problems talking to relays that might be NAT related, try toggling + /// this flag + k_ESteamNetworkingConfig_SDRClient_SingleSocket = 22, + + /// [global string] Code of relay cluster to force use. If not empty, we will + /// only use relays in that cluster. E.g. 'iad' + k_ESteamNetworkingConfig_SDRClient_ForceRelayCluster = 29, + + /// [connection string] For development, a base-64 encoded ticket generated + /// using the cert tool. This can be used to connect to a gameserver via SDR + /// without a ticket generated using the game coordinator. (You will still + /// need a key that is trusted for your app, however.) + /// + /// This can also be passed using the SDR_DEVTICKET environment variable + k_ESteamNetworkingConfig_SDRClient_DevTicket = 30, + + /// [global string] For debugging. Override list of relays from the config with + /// this set (maybe just one). Comma-separated list. + k_ESteamNetworkingConfig_SDRClient_ForceProxyAddr = 31, + + /// [global string] For debugging. Force ping times to clusters to be the specified + /// values. A comma separated list of = values. E.g. "sto=32,iad=100" + /// + /// This is a dev configuration value, you probably should not let users modify it + /// in production. + k_ESteamNetworkingConfig_SDRClient_FakeClusterPing = 36, + + /// [global int32] When probing the SteamDatagram network, we limit exploration + /// to the closest N POPs, based on our current best approximated ping to that POP. + k_ESteamNetworkingConfig_SDRClient_LimitPingProbesToNearestN = 60, + +// +// Log levels for debugging information of various subsystems. +// Higher numeric values will cause more stuff to be printed. +// See ISteamNetworkingUtils::SetDebugOutputFunction for more +// information +// +// The default for all values is k_ESteamNetworkingSocketsDebugOutputType_Warning. +// + k_ESteamNetworkingConfig_LogLevel_AckRTT = 13, // [connection int32] RTT calculations for inline pings and replies + k_ESteamNetworkingConfig_LogLevel_PacketDecode = 14, // [connection int32] log SNP packets send/recv + k_ESteamNetworkingConfig_LogLevel_Message = 15, // [connection int32] log each message send/recv + k_ESteamNetworkingConfig_LogLevel_PacketGaps = 16, // [connection int32] dropped packets + k_ESteamNetworkingConfig_LogLevel_P2PRendezvous = 17, // [connection int32] P2P rendezvous messages + k_ESteamNetworkingConfig_LogLevel_SDRRelayPings = 18, // [global int32] Ping relays + + // Experimental. Set the ECN header field on all outbound UDP packets + // -1 = the default, and means "don't set anything". + // 0..3 = set that value. (Even though 0 is the default UDP ECN value, a 0 here means "explicitly set a 0".) + k_ESteamNetworkingConfig_ECN = 999, + + // Deleted, do not use + k_ESteamNetworkingConfig_DELETED_EnumerateDevVars = 35, + + k_ESteamNetworkingConfigValue__Force32Bit = 0x7fffffff +}; + +// Bitmask of types to share +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Default = -1; // Special value - use user defaults +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Disable = 0; // Do not do any ICE work at all or share any IP addresses with peer +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Relay = 1; // Relayed connection via TURN server. +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Private = 2; // host addresses that appear to be link-local or RFC1918 addresses +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Public = 4; // STUN reflexive addresses, or host address that isn't a "private" address +const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_All = 0x7fffffff; + +/// In a few places we need to set configuration options on listen sockets and connections, and +/// have them take effect *before* the listen socket or connection really starts doing anything. +/// Creating the object and then setting the options "immediately" after creation doesn't work +/// completely, because network packets could be received between the time the object is created and +/// when the options are applied. To set options at creation time in a reliable way, they must be +/// passed to the creation function. This structure is used to pass those options. +/// +/// For the meaning of these fields, see ISteamNetworkingUtils::SetConfigValue. Basically +/// when the object is created, we just iterate over the list of options and call +/// ISteamNetworkingUtils::SetConfigValueStruct, where the scope arguments are supplied by the +/// object being created. +struct SteamNetworkingConfigValue_t +{ + /// Which option is being set + ESteamNetworkingConfigValue m_eValue; + + /// Which field below did you fill in? + ESteamNetworkingConfigDataType m_eDataType; + + /// Option value + union + { + int32_t m_int32; + int64_t m_int64; + float m_float; + const char *m_string; // Points to your '\0'-terminated buffer + void *m_ptr; + } m_val; + + // + // Shortcut helpers to set the type and value in a single call + // + inline void SetInt32( ESteamNetworkingConfigValue eVal, int32_t data ) + { + m_eValue = eVal; + m_eDataType = k_ESteamNetworkingConfig_Int32; + m_val.m_int32 = data; + } + inline void SetInt64( ESteamNetworkingConfigValue eVal, int64_t data ) + { + m_eValue = eVal; + m_eDataType = k_ESteamNetworkingConfig_Int64; + m_val.m_int64 = data; + } + inline void SetFloat( ESteamNetworkingConfigValue eVal, float data ) + { + m_eValue = eVal; + m_eDataType = k_ESteamNetworkingConfig_Float; + m_val.m_float = data; + } + inline void SetPtr( ESteamNetworkingConfigValue eVal, void *data ) + { + m_eValue = eVal; + m_eDataType = k_ESteamNetworkingConfig_Ptr; + m_val.m_ptr = data; + } + inline void SetString( ESteamNetworkingConfigValue eVal, const char *data ) // WARNING - Just saves your pointer. Does NOT make a copy of the string + { + m_eValue = eVal; + m_eDataType = k_ESteamNetworkingConfig_Ptr; + m_val.m_string = data; + } +}; + +/// Return value of ISteamNetworkintgUtils::GetConfigValue +enum ESteamNetworkingGetConfigValueResult +{ + k_ESteamNetworkingGetConfigValue_BadValue = -1, // No such configuration value + k_ESteamNetworkingGetConfigValue_BadScopeObj = -2, // Bad connection handle, etc + k_ESteamNetworkingGetConfigValue_BufferTooSmall = -3, // Couldn't fit the result in your buffer + k_ESteamNetworkingGetConfigValue_OK = 1, + k_ESteamNetworkingGetConfigValue_OKInherited = 2, // A value was not set at this level, but the effective (inherited) value was returned. + + k_ESteamNetworkingGetConfigValueResult__Force32Bit = 0x7fffffff +}; + +// +// Debug output +// + +/// Detail level for diagnostic output callback. +/// See ISteamNetworkingUtils::SetDebugOutputFunction +enum ESteamNetworkingSocketsDebugOutputType +{ + k_ESteamNetworkingSocketsDebugOutputType_None = 0, + k_ESteamNetworkingSocketsDebugOutputType_Bug = 1, // You used the API incorrectly, or an internal error happened + k_ESteamNetworkingSocketsDebugOutputType_Error = 2, // Run-time error condition that isn't the result of a bug. (E.g. we are offline, cannot bind a port, etc) + k_ESteamNetworkingSocketsDebugOutputType_Important = 3, // Nothing is wrong, but this is an important notification + k_ESteamNetworkingSocketsDebugOutputType_Warning = 4, + k_ESteamNetworkingSocketsDebugOutputType_Msg = 5, // Recommended amount + k_ESteamNetworkingSocketsDebugOutputType_Verbose = 6, // Quite a bit + k_ESteamNetworkingSocketsDebugOutputType_Debug = 7, // Practically everything + k_ESteamNetworkingSocketsDebugOutputType_Everything = 8, // Wall of text, detailed packet contents breakdown, etc + + k_ESteamNetworkingSocketsDebugOutputType__Force32Bit = 0x7fffffff +}; + +/// Setup callback for debug output, and the desired verbosity you want. +typedef void (*FSteamNetworkingSocketsDebugOutput)( ESteamNetworkingSocketsDebugOutputType nType, const char *pszMsg ); + +// +// Valve data centers +// + +/// Convert 3- or 4-character ID to 32-bit int. +inline SteamNetworkingPOPID CalculateSteamNetworkingPOPIDFromString( const char *pszCode ) +{ + // OK we made a bad decision when we decided how to pack 3-character codes into a uint32. We'd like to support + // 4-character codes, but we don't want to break compatibility. The migration path has some subtleties that make + // this nontrivial, and there are already some IDs stored in SQL. Ug, so the 4 character code "abcd" will + // be encoded with the digits like "0xddaabbcc". + // + // Also: we don't currently use 1- or 2-character codes, but if ever do in the future, let's make sure don't read + // past the end of the string and access uninitialized memory. (And if the string is empty, we always want + // to return 0 and not read bytes past the '\0'.) + // + // There is also extra paranoia to make sure the bytes are not treated as signed. + SteamNetworkingPOPID result = (uint32)(uint8)pszCode[0] << 16U; + if ( result && pszCode[1] ) + { + result |= ( (uint32)(uint8)pszCode[1] << 8U ); + if ( pszCode[2] ) + { + result |= (uint32)(uint8)pszCode[2] | ( (uint32)(uint8)pszCode[3] << 24U ); + } + } + return result; +} + +/// Unpack integer to string representation, including terminating '\0' +/// +/// See also SteamNetworkingPOPIDRender +template +inline void GetSteamNetworkingLocationPOPStringFromID( SteamNetworkingPOPID id, char (&szCode)[N] ) +{ + static_assert( N >= 5, "Fixed-size buffer not big enough to hold SDR POP ID" ); + szCode[0] = char( id >> 16U ); + szCode[1] = char( id >> 8U ); + szCode[2] = char( id ); + szCode[3] = char( id >> 24U ); // See comment above about deep regret and sadness + szCode[4] = 0; +} + +/// The POPID "dev" is used in non-production environments for testing. +const SteamNetworkingPOPID k_SteamDatagramPOPID_dev = ( (uint32)'d' << 16U ) | ( (uint32)'e' << 8U ) | (uint32)'v'; + +#ifndef API_GEN + +/// Utility class for printing a SteamNetworkingPOPID. +struct SteamNetworkingPOPIDRender +{ + SteamNetworkingPOPIDRender( SteamNetworkingPOPID x ) { GetSteamNetworkingLocationPOPStringFromID( x, buf ); } + inline const char *c_str() const { return buf; } +private: + char buf[ 8 ]; +}; + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Internal stuff +#ifndef API_GEN + +// For code compatibility +typedef SteamNetworkingMessage_t ISteamNetworkingMessage; +typedef SteamNetworkingErrMsg SteamDatagramErrMsg; + +#if 0 +inline void SteamNetworkingIPAddr::Clear() { memset( this, 0, sizeof(*this) ); } +inline bool SteamNetworkingIPAddr::IsIPv6AllZeros() const { const uint64 *q = (const uint64 *)m_ipv6; return q[0] == 0 && q[1] == 0; } +inline void SteamNetworkingIPAddr::SetIPv6( const uint8 *ipv6, uint16 nPort ) { memcpy( m_ipv6, ipv6, 16 ); m_port = nPort; } +inline void SteamNetworkingIPAddr::SetIPv4( uint32 nIP, uint16 nPort ) { m_ipv4.m_8zeros = 0; m_ipv4.m_0000 = 0; m_ipv4.m_ffff = 0xffff; m_ipv4.m_ip[0] = uint8(nIP>>24); m_ipv4.m_ip[1] = uint8(nIP>>16); m_ipv4.m_ip[2] = uint8(nIP>>8); m_ipv4.m_ip[3] = uint8(nIP); m_port = nPort; } +inline bool SteamNetworkingIPAddr::IsIPv4() const { return m_ipv4.m_8zeros == 0 && m_ipv4.m_0000 == 0 && m_ipv4.m_ffff == 0xffff; } +inline uint32 SteamNetworkingIPAddr::GetIPv4() const { return IsIPv4() ? ( (uint32(m_ipv4.m_ip[0])<<24) | (uint32(m_ipv4.m_ip[1])<<16) | (uint32(m_ipv4.m_ip[2])<<8) | uint32(m_ipv4.m_ip[3]) ) : 0; } +inline void SteamNetworkingIPAddr::SetIPv6LocalHost( uint16 nPort ) { m_ipv4.m_8zeros = 0; m_ipv4.m_0000 = 0; m_ipv4.m_ffff = 0; m_ipv6[12] = 0; m_ipv6[13] = 0; m_ipv6[14] = 0; m_ipv6[15] = 1; m_port = nPort; } +inline bool SteamNetworkingIPAddr::IsLocalHost() const { return ( m_ipv4.m_8zeros == 0 && m_ipv4.m_0000 == 0 && m_ipv4.m_ffff == 0 && m_ipv6[12] == 0 && m_ipv6[13] == 0 && m_ipv6[14] == 0 && m_ipv6[15] == 1 ) || ( GetIPv4() == 0x7f000001 ); } +inline bool SteamNetworkingIPAddr::operator==(const SteamNetworkingIPAddr &x ) const { return memcmp( this, &x, sizeof(SteamNetworkingIPAddr) ) == 0; } + +inline void SteamNetworkingIdentity::Clear() { memset( this, 0, sizeof(*this) ); } +inline bool SteamNetworkingIdentity::IsInvalid() const { return m_eType == k_ESteamNetworkingIdentityType_Invalid; } +inline void SteamNetworkingIdentity::SetSteamID( CSteamID steamID ) { SetSteamID64( steamID.ConvertToUint64() ); } +inline CSteamID SteamNetworkingIdentity::GetSteamID() const { return CSteamID( GetSteamID64() ); } +inline void SteamNetworkingIdentity::SetSteamID64( uint64 steamID ) { m_eType = k_ESteamNetworkingIdentityType_SteamID; m_cbSize = sizeof( m_steamID64 ); m_steamID64 = steamID; } +inline uint64 SteamNetworkingIdentity::GetSteamID64() const { return m_eType == k_ESteamNetworkingIdentityType_SteamID ? m_steamID64 : 0; } +inline bool SteamNetworkingIdentity::SetXboxPairwiseID( const char *pszString ) { size_t l = strlen( pszString ); if ( l < 1 || l >= sizeof(m_szXboxPairwiseID) ) return false; + m_eType = k_ESteamNetworkingIdentityType_XboxPairwiseID; m_cbSize = int(l+1); memcpy( m_szXboxPairwiseID, pszString, m_cbSize ); return true; } +inline const char *SteamNetworkingIdentity::GetXboxPairwiseID() const { return m_eType == k_ESteamNetworkingIdentityType_XboxPairwiseID ? m_szXboxPairwiseID : NULL; } +inline void SteamNetworkingIdentity::SetPSNID( uint64 id ) { m_eType = k_ESteamNetworkingIdentityType_SonyPSN; m_cbSize = sizeof( m_PSNID ); m_PSNID = id; } +inline uint64 SteamNetworkingIdentity::GetPSNID() const { return m_eType == k_ESteamNetworkingIdentityType_SonyPSN ? m_PSNID : 0; } +inline void SteamNetworkingIdentity::SetStadiaID( uint64 id ) { m_eType = k_ESteamNetworkingIdentityType_GoogleStadia; m_cbSize = sizeof( m_stadiaID ); m_stadiaID = id; } +inline uint64 SteamNetworkingIdentity::GetStadiaID() const { return m_eType == k_ESteamNetworkingIdentityType_GoogleStadia ? m_stadiaID : 0; } +inline void SteamNetworkingIdentity::SetIPAddr( const SteamNetworkingIPAddr &addr ) { m_eType = k_ESteamNetworkingIdentityType_IPAddress; m_cbSize = (int)sizeof(m_ip); m_ip = addr; } +inline const SteamNetworkingIPAddr *SteamNetworkingIdentity::GetIPAddr() const { return m_eType == k_ESteamNetworkingIdentityType_IPAddress ? &m_ip : NULL; } +inline void SteamNetworkingIdentity::SetIPv4Addr( uint32 nIPv4, uint16 nPort ) { m_eType = k_ESteamNetworkingIdentityType_IPAddress; m_cbSize = (int)sizeof(m_ip); m_ip.SetIPv4( nIPv4, nPort ); } +inline uint32 SteamNetworkingIdentity::GetIPv4() const { return m_eType == k_ESteamNetworkingIdentityType_IPAddress ? m_ip.GetIPv4() : 0; } +inline ESteamNetworkingFakeIPType SteamNetworkingIdentity::GetFakeIPType() const { return m_eType == k_ESteamNetworkingIdentityType_IPAddress ? m_ip.GetFakeIPType() : k_ESteamNetworkingFakeIPType_Invalid; } +inline void SteamNetworkingIdentity::SetLocalHost() { m_eType = k_ESteamNetworkingIdentityType_IPAddress; m_cbSize = (int)sizeof(m_ip); m_ip.SetIPv6LocalHost(); } +inline bool SteamNetworkingIdentity::IsLocalHost() const { return m_eType == k_ESteamNetworkingIdentityType_IPAddress && m_ip.IsLocalHost(); } +inline bool SteamNetworkingIdentity::SetGenericString( const char *pszString ) { size_t l = strlen( pszString ); if ( l >= sizeof(m_szGenericString) ) return false; + m_eType = k_ESteamNetworkingIdentityType_GenericString; m_cbSize = int(l+1); memcpy( m_szGenericString, pszString, m_cbSize ); return true; } +inline const char *SteamNetworkingIdentity::GetGenericString() const { return m_eType == k_ESteamNetworkingIdentityType_GenericString ? m_szGenericString : NULL; } +inline bool SteamNetworkingIdentity::SetGenericBytes( const void *data, size_t cbLen ) { if ( cbLen > sizeof(m_genericBytes) ) return false; + m_eType = k_ESteamNetworkingIdentityType_GenericBytes; m_cbSize = int(cbLen); memcpy( m_genericBytes, data, m_cbSize ); return true; } +inline const uint8 *SteamNetworkingIdentity::GetGenericBytes( int &cbLen ) const { if ( m_eType != k_ESteamNetworkingIdentityType_GenericBytes ) return NULL; + cbLen = m_cbSize; return m_genericBytes; } +inline bool SteamNetworkingIdentity::operator==(const SteamNetworkingIdentity &x ) const { return m_eType == x.m_eType && m_cbSize == x.m_cbSize && memcmp( m_genericBytes, x.m_genericBytes, m_cbSize ) == 0; } +inline void SteamNetworkingMessage_t::Release() { (*m_pfnRelease)( this ); } +#endif + +#endif // #ifndef API_GEN + +#endif // #ifndef STEAMNETWORKINGTYPES diff --git a/lsteamclient/steamworks_sdk_160/steamps3params.h b/lsteamclient/steamworks_sdk_160/steamps3params.h new file mode 100644 index 0000000000..c0741b4bb0 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamps3params.h @@ -0,0 +1,112 @@ +//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= +// +// Purpose: +// +//============================================================================= + +#ifndef STEAMPS3PARAMS_H +#define STEAMPS3PARAMS_H +#ifdef _WIN32 +#pragma once +#endif + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// PlayStation 3 initialization parameters +// +// The following structure must be passed to when loading steam_api_ps3.prx +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +#define STEAM_PS3_PATH_MAX 1055 +#define STEAM_PS3_SERVICE_ID_MAX 32 +#define STEAM_PS3_COMMUNICATION_ID_MAX 10 +#define STEAM_PS3_COMMUNICATION_SIG_MAX 160 +#define STEAM_PS3_LANGUAGE_MAX 64 +#define STEAM_PS3_REGION_CODE_MAX 16 +#define STEAM_PS3_CURRENT_PARAMS_VER 2 +struct SteamPS3Params_t +{ + uint32 m_unVersion; // set to STEAM_PS3_CURRENT_PARAMS_VER + + void *pReserved; + uint32 m_nAppId; // set to your game's appid + + char m_rgchInstallationPath[ STEAM_PS3_PATH_MAX ]; // directory containing latest steam prx's and sdata. Can be read only (BDVD) + char m_rgchSystemCache[ STEAM_PS3_PATH_MAX ]; // temp working cache, not persistent + char m_rgchGameData[ STEAM_PS3_PATH_MAX ]; // persistent game data path for storing user data + char m_rgchNpServiceID[ STEAM_PS3_SERVICE_ID_MAX ]; + char m_rgchNpCommunicationID[ STEAM_PS3_COMMUNICATION_ID_MAX ]; + char m_rgchNpCommunicationSig[ STEAM_PS3_COMMUNICATION_SIG_MAX ]; + + // Language should be one of the following. must be zero terminated + // danish + // dutch + // english + // finnish + // french + // german + // italian + // korean + // norwegian + // polish + // portuguese + // russian + // schinese + // spanish + // swedish + // tchinese + char m_rgchSteamLanguage[ STEAM_PS3_LANGUAGE_MAX ]; + + // region codes are "SCEA", "SCEE", "SCEJ". must be zero terminated + char m_rgchRegionCode[ STEAM_PS3_REGION_CODE_MAX ]; + + // Should be SYS_TTYP3 through SYS_TTYP10, if it's 0 then Steam won't spawn a + // thread to read console input at all. Using this let's you use Steam console commands + // like: profile_on, profile_off, profile_dump, mem_stats, mem_validate. + unsigned int m_cSteamInputTTY; + + struct Ps3netInit_t + { + bool m_bNeedInit; + void *m_pMemory; + int m_nMemorySize; + int m_flags; + } m_sysNetInitInfo; + + struct Ps3jpgInit_t + { + bool m_bNeedInit; + } m_sysJpgInitInfo; + + struct Ps3pngInit_t + { + bool m_bNeedInit; + } m_sysPngInitInfo; + + struct Ps3sysutilUserInfo_t + { + bool m_bNeedInit; + } m_sysSysUtilUserInfo; + + bool m_bIncludeNewsPage; +}; + + +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// PlayStation 3 memory structure +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +#define STEAMPS3_MALLOC_INUSE 0x53D04A51 +#define STEAMPS3_MALLOC_SYSTEM 0x0D102C48 +#define STEAMPS3_MALLOC_OK 0xFFD04A51 +struct SteamPS3Memory_t +{ + bool m_bSingleAllocation; // If true, Steam will request one 6MB allocation and use the returned memory for all future allocations + // If false, Steam will make call malloc for each allocation + + // required function pointers + void* (*m_pfMalloc)(size_t); + void* (*m_pfRealloc)(void *, size_t); + void (*m_pfFree)(void *); + size_t (*m_pUsable_size)(void*); +}; + + +#endif // STEAMPS3PARAMS_H diff --git a/lsteamclient/steamworks_sdk_160/steamtypes.h b/lsteamclient/steamworks_sdk_160/steamtypes.h new file mode 100644 index 0000000000..a9eb548bb5 --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamtypes.h @@ -0,0 +1,156 @@ +//========= Copyright 1996-2022, Valve LLC, All rights reserved. ============ + +#ifndef STEAMTYPES_H +#define STEAMTYPES_H + +#define S_CALLTYPE __cdecl +// WARNING: __cdecl is potentially #defined away in steam_api_common.h + +// Steam-specific types. Defined here so this header file can be included in other code bases. +#ifndef WCHARTYPES_H +typedef unsigned char uint8; +#endif + +#if defined( __GNUC__ ) && !defined(POSIX) + #if __GNUC__ < 4 + #error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)" + #endif +#endif + +#if defined(__LP64__) || defined(__x86_64__) || defined(_WIN64) || defined(__aarch64__) || defined(__s390x__) +#define X64BITS +#endif + +#if !defined(VALVE_BIG_ENDIAN) +#if defined(_PS3) +// Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code. +#define VALVE_BIG_ENDIAN 1 +#endif +#if defined( __GNUC__ ) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +#define VALVE_BIG_ENDIAN 1 +#endif +#endif + +typedef unsigned char uint8; +typedef signed char int8; + +#if defined( _WIN32 ) && !defined( __GNUC__ ) + +typedef __int16 int16; +typedef unsigned __int16 uint16; +typedef __int32 int32; +typedef unsigned __int32 uint32; +typedef __int64 int64; +typedef unsigned __int64 uint64; + +typedef int64 lint64; +typedef uint64 ulint64; + +#ifdef X64BITS +typedef __int64 intp; // intp is an integer that can accomodate a pointer +typedef unsigned __int64 uintp; // (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *) +#else +typedef __int32 intp; +typedef unsigned __int32 uintp; +#endif + +#else // _WIN32 + +typedef short int16; +typedef unsigned short uint16; +typedef int int32; +typedef unsigned int uint32; +typedef long long int64; +typedef unsigned long long uint64; + +// [u]int64 are actually defined as 'long long' and gcc 64-bit +// doesn't automatically consider them the same as 'long int'. +// Changing the types for [u]int64 is complicated by +// there being many definitions, so we just +// define a 'long int' here and use it in places that would +// otherwise confuse the compiler. +typedef long int lint64; +typedef unsigned long int ulint64; + +#ifdef X64BITS +typedef long long intp; +typedef unsigned long long uintp; +#else +typedef int intp; +typedef unsigned int uintp; +#endif + +#endif // else _WIN32 + +typedef uint32 AppId_t; +const AppId_t k_uAppIdInvalid = 0x0; + +// AppIds and DepotIDs also presently share the same namespace +typedef uint32 DepotId_t; +const DepotId_t k_uDepotIdInvalid = 0x0; + +// RTime32. Seconds elapsed since Jan 1 1970, i.e. unix timestamp. +// It's the same as time_t, but it is always 32-bit and unsigned. +typedef uint32 RTime32; + +// handle to a Steam API call +typedef uint64 SteamAPICall_t; +const SteamAPICall_t k_uAPICallInvalid = 0x0; + +typedef uint32 AccountID_t; +const AccountID_t k_uAccountIdInvalid = 0; + +// Party Beacon ID +typedef uint64 PartyBeaconID_t; +const PartyBeaconID_t k_ulPartyBeaconIdInvalid = 0; + +enum ESteamIPType +{ + k_ESteamIPTypeIPv4 = 0, + k_ESteamIPTypeIPv6 = 1, +}; + +#pragma pack( push, 1 ) + +struct SteamIPAddress_t +{ + union x { + + uint32 m_unIPv4; // Host order + uint8 m_rgubIPv6[16]; // Network order! Same as inaddr_in6. (0011:2233:4455:6677:8899:aabb:ccdd:eeff) + + // Internal use only + uint64 m_ipv6Qword[2]; // big endian + } x; + + ESteamIPType m_eType; + + bool IsSet() const + { + return true; + } + + static SteamIPAddress_t IPv4Any() + { + return {}; + } + + static SteamIPAddress_t IPv6Any() + { + return {}; + } + + static SteamIPAddress_t IPv4Loopback() + { + return {}; + } + + static SteamIPAddress_t IPv6Loopback() + { + return {}; + } +}; + +#pragma pack( pop ) + +#endif // STEAMTYPES_H diff --git a/lsteamclient/steamworks_sdk_160/steamuniverse.h b/lsteamclient/steamworks_sdk_160/steamuniverse.h new file mode 100644 index 0000000000..dd384dcc4c --- /dev/null +++ b/lsteamclient/steamworks_sdk_160/steamuniverse.h @@ -0,0 +1,27 @@ +//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ +// +// Purpose: +// +//============================================================================= + +#ifndef STEAMUNIVERSE_H +#define STEAMUNIVERSE_H +#ifdef _WIN32 +#pragma once +#endif + + +// Steam universes. Each universe is a self-contained Steam instance. +enum EUniverse +{ + k_EUniverseInvalid = 0, + k_EUniversePublic = 1, + k_EUniverseBeta = 2, + k_EUniverseInternal = 3, + k_EUniverseDev = 4, + // k_EUniverseRC = 5, // no such universe anymore + k_EUniverseMax +}; + + +#endif // STEAMUNIVERSE_H From c45ec7dead631d4f1c11b6f1c131902bf82646dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 27 Jun 2024 17:28:28 +0200 Subject: [PATCH 032/141] lsteamclient: Generate SteamWorks SDK 1.60 support. CW-Bug-Id: #23976 --- lsteamclient/Makefile.in | 2 + ...eamApps_STEAMAPPS_INTERFACE_VERSION008.cpp | 24 + ...SteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp | 773 +++++++++ ...pISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp | 39 + lsteamclient/gen_wrapper.py | 1 + lsteamclient/steamclient_generated.c | 2 + lsteamclient/steamclient_generated.h | 2 + lsteamclient/steamclient_structs_generated.h | 351 +++- lsteamclient/unix_private_generated.h | 214 +++ lsteamclient/unixlib_generated.cpp | 929 ++++++++-- lsteamclient/unixlib_generated.h | 950 +++++++++++ lsteamclient/winISteamApps.c | 52 +- lsteamclient/winISteamUGC.c | 1497 +++++++++++++++++ lsteamclient/winISteamVideo.c | 76 + 14 files changed, 4735 insertions(+), 177 deletions(-) create mode 100644 lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp create mode 100644 lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp diff --git a/lsteamclient/Makefile.in b/lsteamclient/Makefile.in index 03b809c9af..94a10c255a 100644 --- a/lsteamclient/Makefile.in +++ b/lsteamclient/Makefile.in @@ -199,6 +199,7 @@ SOURCES = \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION016.cpp \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION017.cpp \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION018.cpp \ + cppISteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp \ cppISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001.cpp \ cppISteamUser_SteamUser004.cpp \ cppISteamUser_SteamUser005.cpp \ @@ -242,6 +243,7 @@ SOURCES = \ cppISteamUtils_SteamUtils010.cpp \ cppISteamVideo_STEAMVIDEO_INTERFACE_V001.cpp \ cppISteamVideo_STEAMVIDEO_INTERFACE_V002.cpp \ + cppISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp \ unix_steam_input_manual.cpp \ unix_steam_networking_manual.cpp \ unix_steam_utils_manual.cpp \ diff --git a/lsteamclient/cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.cpp b/lsteamclient/cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.cpp index a81fc0f622..4286534698 100644 --- a/lsteamclient/cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.cpp +++ b/lsteamclient/cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.cpp @@ -248,3 +248,27 @@ NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext( void *args ) return 0; } +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas( void *args ) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas_params *params = (struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas_params *)args; + struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *iface = (struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *)params->linux_side; + params->_ret = iface->GetNumBetas( params->pnAvailable, params->pnPrivate ); + return 0; +} + +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo( void *args ) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo_params *params = (struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo_params *)args; + struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *iface = (struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *)params->linux_side; + params->_ret = iface->GetBetaInfo( params->iBetaIndex, params->punFlags, params->punBuildID, params->pchBetaName, params->cchBetaName, params->pchDescription, params->cchDescription ); + return 0; +} + +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta( void *args ) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta_params *params = (struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta_params *)args; + struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *iface = (struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 *)params->linux_side; + params->_ret = iface->SetActiveBeta( params->pchBetaName ); + return 0; +} + diff --git a/lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp b/lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp new file mode 100644 index 0000000000..27512a64f8 --- /dev/null +++ b/lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION020.cpp @@ -0,0 +1,773 @@ +/* This file is auto-generated, do not edit. */ +#include "unix_private.h" + +#if 0 +#pragma makedep unix +#endif + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->CreateQueryUserUGCRequest( params->unAccountID, params->eListType, params->eMatchingUGCType, params->eSortOrder, params->nCreatorAppID, params->nConsumerAppID, params->unPage ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->CreateQueryAllUGCRequest( params->eQueryType, params->eMatchingeMatchingUGCTypeFileType, params->nCreatorAppID, params->nConsumerAppID, params->unPage ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->CreateQueryAllUGCRequest( params->eQueryType, params->eMatchingeMatchingUGCTypeFileType, params->nCreatorAppID, params->nConsumerAppID, params->pchCursor ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->CreateQueryUGCDetailsRequest( params->pvecPublishedFileID, params->unNumPublishedFileIDs ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SendQueryUGCRequest( params->handle ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + u_SteamUGCDetails_t_160 u_pDetails = *params->pDetails; + params->_ret = iface->GetQueryUGCResult( params->handle, params->index, &u_pDetails ); + *params->pDetails = u_pDetails; + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCNumTags( params->handle, params->index ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCTag( params->handle, params->index, params->indexTag, params->pchValue, params->cchValueSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCTagDisplayName( params->handle, params->index, params->indexTag, params->pchValue, params->cchValueSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCPreviewURL( params->handle, params->index, params->pchURL, params->cchURLSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCMetadata( params->handle, params->index, params->pchMetadata, params->cchMetadatasize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCChildren( params->handle, params->index, params->pvecPublishedFileID, params->cMaxEntries ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCStatistic( params->handle, params->index, params->eStatType, params->pStatValue ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCNumAdditionalPreviews( params->handle, params->index ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCAdditionalPreview( params->handle, params->index, params->previewIndex, params->pchURLOrVideoID, params->cchURLSize, params->pchOriginalFileName, params->cchOriginalFileNameSize, params->pPreviewType ); + steamclient_unix_path_to_dos_path( params->_ret, params->pchURLOrVideoID, params->pchURLOrVideoID, params->cchURLSize, 1 ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCNumKeyValueTags( params->handle, params->index ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCKeyValueTag( params->handle, params->index, params->keyValueTagIndex, params->pchKey, params->cchKeySize, params->pchValue, params->cchValueSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCKeyValueTag( params->handle, params->index, params->pchKey, params->pchValue, params->cchValueSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetNumSupportedGameVersions( params->handle, params->index ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetSupportedGameVersionData( params->handle, params->index, params->versionIndex, params->pchGameBranchMin, params->pchGameBranchMax, params->cchGameBranchSize ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetQueryUGCContentDescriptors( params->handle, params->index, params->pvecDescriptors, params->cMaxEntries ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->ReleaseQueryUGCRequest( params->handle ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddRequiredTag( params->handle, params->pTagName ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddRequiredTagGroup( params->handle, params->pTagGroups ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddExcludedTag( params->handle, params->pTagName ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnOnlyIDs( params->handle, params->bReturnOnlyIDs ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnKeyValueTags( params->handle, params->bReturnKeyValueTags ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnLongDescription( params->handle, params->bReturnLongDescription ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnMetadata( params->handle, params->bReturnMetadata ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnChildren( params->handle, params->bReturnChildren ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnAdditionalPreviews( params->handle, params->bReturnAdditionalPreviews ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnTotalOnly( params->handle, params->bReturnTotalOnly ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetReturnPlaytimeStats( params->handle, params->unDays ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetLanguage( params->handle, params->pchLanguage ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetAllowCachedResponse( params->handle, params->unMaxAgeSeconds ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetAdminQuery( params->handle, params->bAdminQuery ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetCloudFileNameFilter( params->handle, params->pMatchCloudFileName ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetMatchAnyTag( params->handle, params->bMatchAnyTag ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetSearchText( params->handle, params->pSearchText ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetRankedByTrendDays( params->handle, params->unDays ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetTimeCreatedDateRange( params->handle, params->rtStart, params->rtEnd ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetTimeUpdatedDateRange( params->handle, params->rtStart, params->rtEnd ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddRequiredKeyValueTag( params->handle, params->pKey, params->pValue ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RequestUGCDetails( params->nPublishedFileID, params->unMaxAgeSeconds ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->CreateItem( params->nConsumerAppId, params->eFileType ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->StartItemUpdate( params->nConsumerAppId, params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemTitle( params->handle, params->pchTitle ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemDescription( params->handle, params->pchDescription ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemUpdateLanguage( params->handle, params->pchLanguage ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemMetadata( params->handle, params->pchMetaData ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemVisibility( params->handle, params->eVisibility ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetItemTags( params->updateHandle, params->pTags, params->bAllowAdminTags ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + char *u_pszContentFolder = steamclient_dos_to_unix_path( params->pszContentFolder, 0 ); + params->_ret = iface->SetItemContent( params->handle, u_pszContentFolder ); + steamclient_free_path( u_pszContentFolder ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + char *u_pszPreviewFile = steamclient_dos_to_unix_path( params->pszPreviewFile, 0 ); + params->_ret = iface->SetItemPreview( params->handle, u_pszPreviewFile ); + steamclient_free_path( u_pszPreviewFile ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetAllowLegacyUpload( params->handle, params->bAllowLegacyUpload ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveAllItemKeyValueTags( params->handle ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveItemKeyValueTags( params->handle, params->pchKey ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddItemKeyValueTag( params->handle, params->pchKey, params->pchValue ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + char *u_pszPreviewFile = steamclient_dos_to_unix_path( params->pszPreviewFile, 0 ); + params->_ret = iface->AddItemPreviewFile( params->handle, u_pszPreviewFile, params->type ); + steamclient_free_path( u_pszPreviewFile ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddItemPreviewVideo( params->handle, params->pszVideoID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + char *u_pszPreviewFile = steamclient_dos_to_unix_path( params->pszPreviewFile, 0 ); + params->_ret = iface->UpdateItemPreviewFile( params->handle, params->index, u_pszPreviewFile ); + steamclient_free_path( u_pszPreviewFile ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->UpdateItemPreviewVideo( params->handle, params->index, params->pszVideoID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveItemPreview( params->handle, params->index ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddContentDescriptor( params->handle, params->descid ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveContentDescriptor( params->handle, params->descid ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetRequiredGameVersions( params->handle, params->pszGameBranchMin, params->pszGameBranchMax ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SubmitItemUpdate( params->handle, params->pchChangeNote ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetItemUpdateProgress( params->handle, params->punBytesProcessed, params->punBytesTotal ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SetUserItemVote( params->nPublishedFileID, params->bVoteUp ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetUserItemVote( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddItemToFavorites( params->nAppId, params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveItemFromFavorites( params->nAppId, params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->SubscribeItem( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->UnsubscribeItem( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetNumSubscribedItems( ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetSubscribedItems( params->pvecPublishedFileID, params->cMaxEntries ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetItemState( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetItemInstallInfo( params->nPublishedFileID, params->punSizeOnDisk, params->pchFolder, params->cchFolderSize, params->punTimeStamp ); + steamclient_unix_path_to_dos_path( params->_ret, params->pchFolder, params->pchFolder, params->cchFolderSize, 0 ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetItemDownloadInfo( params->nPublishedFileID, params->punBytesDownloaded, params->punBytesTotal ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->DownloadItem( params->nPublishedFileID, params->bHighPriority ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + char *u_pszFolder = steamclient_dos_to_unix_path( params->pszFolder, 0 ); + params->_ret = iface->BInitWorkshopForGameServer( params->unWorkshopDepotID, u_pszFolder ); + steamclient_free_path( u_pszFolder ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + iface->SuspendDownloads( params->bSuspend ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->StartPlaytimeTracking( params->pvecPublishedFileID, params->unNumPublishedFileIDs ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->StopPlaytimeTracking( params->pvecPublishedFileID, params->unNumPublishedFileIDs ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->StopPlaytimeTrackingForAllItems( ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddDependency( params->nParentPublishedFileID, params->nChildPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveDependency( params->nParentPublishedFileID, params->nChildPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->AddAppDependency( params->nPublishedFileID, params->nAppID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->RemoveAppDependency( params->nPublishedFileID, params->nAppID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetAppDependencies( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->DeleteItem( params->nPublishedFileID ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->ShowWorkshopEULA( ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetWorkshopEULAStatus( ); + return 0; +} + +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences( void *args ) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences_params *params = (struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences_params *)args; + struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *iface = (struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 *)params->linux_side; + params->_ret = iface->GetUserContentDescriptorPreferences( params->pvecDescriptors, params->cMaxEntries ); + return 0; +} + diff --git a/lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp b/lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp new file mode 100644 index 0000000000..c3d56fbb4c --- /dev/null +++ b/lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V007.cpp @@ -0,0 +1,39 @@ +/* This file is auto-generated, do not edit. */ +#include "unix_private.h" + +#if 0 +#pragma makedep unix +#endif + +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL( void *args ) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL_params *params = (struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL_params *)args; + struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *iface = (struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *)params->linux_side; + iface->GetVideoURL( params->unVideoAppID ); + return 0; +} + +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting( void *args ) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting_params *params = (struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting_params *)args; + struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *iface = (struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *)params->linux_side; + params->_ret = iface->IsBroadcasting( params->pnNumViewers ); + return 0; +} + +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings( void *args ) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings_params *params = (struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings_params *)args; + struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *iface = (struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *)params->linux_side; + iface->GetOPFSettings( params->unVideoAppID ); + return 0; +} + +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp( void *args ) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp_params *params = (struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp_params *)args; + struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *iface = (struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 *)params->linux_side; + params->_ret = iface->GetOPFStringForApp( params->unVideoAppID, params->pchBuffer, params->pnBufferSize ); + return 0; +} + diff --git a/lsteamclient/gen_wrapper.py b/lsteamclient/gen_wrapper.py index ec82142bb7..c21733bdc1 100755 --- a/lsteamclient/gen_wrapper.py +++ b/lsteamclient/gen_wrapper.py @@ -11,6 +11,7 @@ import re SDK_VERSIONS = [ + "160", "159", "158", "157", diff --git a/lsteamclient/steamclient_generated.c b/lsteamclient/steamclient_generated.c index bb688cdbc3..a6da3610d8 100644 --- a/lsteamclient/steamclient_generated.c +++ b/lsteamclient/steamclient_generated.c @@ -67,6 +67,7 @@ static const struct { const char *iface_version; iface_constructor ctor; } const {"STEAMUGC_INTERFACE_VERSION016", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION016}, {"STEAMUGC_INTERFACE_VERSION017", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION017}, {"STEAMUGC_INTERFACE_VERSION018", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION018}, + {"STEAMUGC_INTERFACE_VERSION020", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION020}, {"STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001", &create_winISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001}, {"STEAMUSERSTATS_INTERFACE_VERSION001", &create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION001}, {"STEAMUSERSTATS_INTERFACE_VERSION002", &create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION002}, @@ -82,6 +83,7 @@ static const struct { const char *iface_version; iface_constructor ctor; } const {"STEAMUSERSTATS_INTERFACE_VERSION012", &create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012}, {"STEAMVIDEO_INTERFACE_V001", &create_winISteamVideo_STEAMVIDEO_INTERFACE_V001}, {"STEAMVIDEO_INTERFACE_V002", &create_winISteamVideo_STEAMVIDEO_INTERFACE_V002}, + {"STEAMVIDEO_INTERFACE_V007", &create_winISteamVideo_STEAMVIDEO_INTERFACE_V007}, {"SteamClient006", &create_winISteamClient_SteamClient006}, {"SteamClient007", &create_winISteamClient_SteamClient007}, {"SteamClient008", &create_winISteamClient_SteamClient008}, diff --git a/lsteamclient/steamclient_generated.h b/lsteamclient/steamclient_generated.h index fd22b85dc3..1972915489 100644 --- a/lsteamclient/steamclient_generated.h +++ b/lsteamclient/steamclient_generated.h @@ -62,6 +62,7 @@ extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION015(v extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION016(void *); extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION017(void *); extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION018(void *); +extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION020(void *); extern struct w_steam_iface *create_winISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001(void *); extern struct w_steam_iface *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION001(void *); extern struct w_steam_iface *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION002(void *); @@ -77,6 +78,7 @@ extern struct w_steam_iface *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_ extern struct w_steam_iface *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012(void *); extern struct w_steam_iface *create_winISteamVideo_STEAMVIDEO_INTERFACE_V001(void *); extern struct w_steam_iface *create_winISteamVideo_STEAMVIDEO_INTERFACE_V002(void *); +extern struct w_steam_iface *create_winISteamVideo_STEAMVIDEO_INTERFACE_V007(void *); extern struct w_steam_iface *create_winISteamClient_SteamClient006(void *); extern struct w_steam_iface *create_winISteamClient_SteamClient007(void *); extern struct w_steam_iface *create_winISteamClient_SteamClient008(void *); diff --git a/lsteamclient/steamclient_structs_generated.h b/lsteamclient/steamclient_structs_generated.h index 6c349caaf6..33381e72b9 100644 --- a/lsteamclient/steamclient_structs_generated.h +++ b/lsteamclient/steamclient_structs_generated.h @@ -2343,6 +2343,10 @@ struct gameserveritem_t_099u }; #pragma pack( pop ) +typedef struct u64_SteamUGCDetails_t_160 u64_SteamUGCDetails_t_160; +typedef struct w64_SteamUGCDetails_t_160 w64_SteamUGCDetails_t_160; +typedef struct u32_SteamUGCDetails_t_160 u32_SteamUGCDetails_t_160; +typedef struct w32_SteamUGCDetails_t_160 w32_SteamUGCDetails_t_160; typedef struct u64_SteamUGCDetails_t_128x u64_SteamUGCDetails_t_128x; typedef struct w64_SteamUGCDetails_t_128x w64_SteamUGCDetails_t_128x; typedef struct u32_SteamUGCDetails_t_128x u32_SteamUGCDetails_t_128x; @@ -2563,10 +2567,20 @@ typedef struct u_ISteamNetworkingCustomSignalingRecvContext u32_ISteamNetworking typedef struct w_ISteamNetworkingCustomSignalingRecvContext w_ISteamNetworkingCustomSignalingRecvContext; typedef struct w_ISteamNetworkingCustomSignalingRecvContext w64_ISteamNetworkingCustomSignalingRecvContext; typedef struct w_ISteamNetworkingCustomSignalingRecvContext w32_ISteamNetworkingCustomSignalingRecvContext; -typedef struct u64_ItemInstalled_t u64_ItemInstalled_t; -typedef struct w64_ItemInstalled_t w64_ItemInstalled_t; -typedef struct u32_ItemInstalled_t u32_ItemInstalled_t; -typedef struct w32_ItemInstalled_t w32_ItemInstalled_t; +typedef struct u_ISteamTimeline u_ISteamTimeline; +typedef struct u_ISteamTimeline u64_ISteamTimeline; +typedef struct u_ISteamTimeline u32_ISteamTimeline; +typedef struct w_ISteamTimeline w_ISteamTimeline; +typedef struct w_ISteamTimeline w64_ISteamTimeline; +typedef struct w_ISteamTimeline w32_ISteamTimeline; +typedef struct u64_ItemInstalled_t_160 u64_ItemInstalled_t_160; +typedef struct w64_ItemInstalled_t_160 w64_ItemInstalled_t_160; +typedef struct u32_ItemInstalled_t_160 u32_ItemInstalled_t_160; +typedef struct w32_ItemInstalled_t_160 w32_ItemInstalled_t_160; +typedef struct u64_ItemInstalled_t_130 u64_ItemInstalled_t_130; +typedef struct w64_ItemInstalled_t_130 w64_ItemInstalled_t_130; +typedef struct u32_ItemInstalled_t_130 u32_ItemInstalled_t_130; +typedef struct w32_ItemInstalled_t_130 w32_ItemInstalled_t_130; typedef struct u64_JoinPartyCallback_t u64_JoinPartyCallback_t; typedef struct w64_JoinPartyCallback_t w64_JoinPartyCallback_t; typedef struct u32_JoinPartyCallback_t u32_JoinPartyCallback_t; @@ -2871,6 +2885,10 @@ typedef struct u64_SteamPartyBeaconLocation_t u64_SteamPartyBeaconLocation_t; typedef struct w64_SteamPartyBeaconLocation_t w64_SteamPartyBeaconLocation_t; typedef struct u32_SteamPartyBeaconLocation_t u32_SteamPartyBeaconLocation_t; typedef struct w32_SteamPartyBeaconLocation_t w32_SteamPartyBeaconLocation_t; +typedef struct u64_SteamUGCRequestUGCDetailsResult_t_160 u64_SteamUGCRequestUGCDetailsResult_t_160; +typedef struct w64_SteamUGCRequestUGCDetailsResult_t_160 w64_SteamUGCRequestUGCDetailsResult_t_160; +typedef struct u32_SteamUGCRequestUGCDetailsResult_t_160 u32_SteamUGCRequestUGCDetailsResult_t_160; +typedef struct w32_SteamUGCRequestUGCDetailsResult_t_160 w32_SteamUGCRequestUGCDetailsResult_t_160; typedef struct u64_SteamUGCRequestUGCDetailsResult_t_128x u64_SteamUGCRequestUGCDetailsResult_t_128x; typedef struct w64_SteamUGCRequestUGCDetailsResult_t_128x w64_SteamUGCRequestUGCDetailsResult_t_128x; typedef struct u32_SteamUGCRequestUGCDetailsResult_t_128x u32_SteamUGCRequestUGCDetailsResult_t_128x; @@ -2887,6 +2905,167 @@ typedef struct u64_SubmitPlayerResultResultCallback_t u64_SubmitPlayerResultResu typedef struct w64_SubmitPlayerResultResultCallback_t w64_SubmitPlayerResultResultCallback_t; typedef struct u32_SubmitPlayerResultResultCallback_t u32_SubmitPlayerResultResultCallback_t; typedef struct w32_SubmitPlayerResultResultCallback_t w32_SubmitPlayerResultResultCallback_t; +#pragma pack( push, 8 ) +struct w64_SteamUGCDetails_t_160 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + int8_t m_bBanned; + int8_t m_bAcceptedForUse; + int8_t m_bTagsTruncated; + W64_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint8_t __pad_9772[4]; + uint64_t m_ulTotalFilesSize; +#ifdef __cplusplus + operator u64_SteamUGCDetails_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCDetails_t_160 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U64_ARRAY(char, 129, m_rgchTitle); + U64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + int8_t m_bBanned; + int8_t m_bAcceptedForUse; + int8_t m_bTagsTruncated; + U64_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint64_t m_ulTotalFilesSize; +#ifdef __cplusplus + operator w64_SteamUGCDetails_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCDetails_t_160 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + int8_t m_bBanned; + int8_t m_bAcceptedForUse; + int8_t m_bTagsTruncated; + W32_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint8_t __pad_9772[4]; + uint64_t m_ulTotalFilesSize; +#ifdef __cplusplus + operator u32_SteamUGCDetails_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCDetails_t_160 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + int8_t m_bBanned; + int8_t m_bAcceptedForUse; + int8_t m_bTagsTruncated; + U32_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint64_t m_ulTotalFilesSize; +#ifdef __cplusplus + operator w32_SteamUGCDetails_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCDetails_t_160 w_SteamUGCDetails_t_160; +typedef u32_SteamUGCDetails_t_160 u_SteamUGCDetails_t_160; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCDetails_t_160 w_SteamUGCDetails_t_160; +typedef u64_SteamUGCDetails_t_160 u_SteamUGCDetails_t_160; +#endif + #pragma pack( push, 8 ) struct w64_SteamUGCDetails_t_128x { @@ -5682,59 +5861,142 @@ struct u_ISteamNetworkingCustomSignalingRecvContext #endif /* __cplusplus */ }; +struct w_ISteamTimeline +{ +#ifdef __cplusplus + virtual void SetTimelineStateDescription( const char *, float ) = 0; + virtual void ClearTimelineStateDescription( float ) = 0; + virtual void AddTimelineEvent( const char *, const char *, const char *, uint32_t, float, float, uint32_t ) = 0; + virtual void SetTimelineGameMode( uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamTimeline +{ +#ifdef __cplusplus + virtual void SetTimelineStateDescription( const char *, float ) = 0; + virtual void ClearTimelineStateDescription( float ) = 0; + virtual void AddTimelineEvent( const char *, const char *, const char *, uint32_t, float, float, uint32_t ) = 0; + virtual void SetTimelineGameMode( uint32_t ) = 0; +#endif /* __cplusplus */ +}; + #pragma pack( push, 8 ) -struct w64_ItemInstalled_t +struct w64_ItemInstalled_t_160 { uint32_t m_unAppID; uint8_t __pad_4[4]; uint64_t m_nPublishedFileId; + uint64_t m_hLegacyContent; + uint64_t m_unManifestID; #ifdef __cplusplus - operator u64_ItemInstalled_t() const; + operator u64_ItemInstalled_t_160() const; #endif /* __cplusplus */ }; #pragma pack( pop ) #pragma pack( push, 4 ) -struct u64_ItemInstalled_t +struct u64_ItemInstalled_t_160 { uint32_t m_unAppID; uint64_t m_nPublishedFileId; + uint64_t m_hLegacyContent; + uint64_t m_unManifestID; #ifdef __cplusplus - operator w64_ItemInstalled_t() const; + operator w64_ItemInstalled_t_160() const; #endif /* __cplusplus */ }; #pragma pack( pop ) #pragma pack( push, 8 ) -struct w32_ItemInstalled_t +struct w32_ItemInstalled_t_160 { uint32_t m_unAppID; uint8_t __pad_4[4]; uint64_t m_nPublishedFileId; + uint64_t m_hLegacyContent; + uint64_t m_unManifestID; #ifdef __cplusplus - operator u32_ItemInstalled_t() const; + operator u32_ItemInstalled_t_160() const; #endif /* __cplusplus */ }; #pragma pack( pop ) #pragma pack( push, 4 ) -struct u32_ItemInstalled_t +struct u32_ItemInstalled_t_160 { uint32_t m_unAppID; uint64_t m_nPublishedFileId; + uint64_t m_hLegacyContent; + uint64_t m_unManifestID; #ifdef __cplusplus - operator w32_ItemInstalled_t() const; + operator w32_ItemInstalled_t_160() const; #endif /* __cplusplus */ }; #pragma pack( pop ) #ifdef __i386__ -typedef w32_ItemInstalled_t w_ItemInstalled_t; -typedef u32_ItemInstalled_t u_ItemInstalled_t; +typedef w32_ItemInstalled_t_160 w_ItemInstalled_t_160; +typedef u32_ItemInstalled_t_160 u_ItemInstalled_t_160; #endif #ifdef __x86_64__ -typedef w64_ItemInstalled_t w_ItemInstalled_t; -typedef u64_ItemInstalled_t u_ItemInstalled_t; +typedef w64_ItemInstalled_t_160 w_ItemInstalled_t_160; +typedef u64_ItemInstalled_t_160 u_ItemInstalled_t_160; +#endif + +#pragma pack( push, 8 ) +struct w64_ItemInstalled_t_130 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +#ifdef __cplusplus + operator u64_ItemInstalled_t_130() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_ItemInstalled_t_130 +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; +#ifdef __cplusplus + operator w64_ItemInstalled_t_130() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_ItemInstalled_t_130 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +#ifdef __cplusplus + operator u32_ItemInstalled_t_130() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_ItemInstalled_t_130 +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; +#ifdef __cplusplus + operator w32_ItemInstalled_t_130() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_ItemInstalled_t_130 w_ItemInstalled_t_130; +typedef u32_ItemInstalled_t_130 u_ItemInstalled_t_130; +#endif +#ifdef __x86_64__ +typedef w64_ItemInstalled_t_130 w_ItemInstalled_t_130; +typedef u64_ItemInstalled_t_130 u_ItemInstalled_t_130; #endif #pragma pack( push, 8 ) @@ -10432,6 +10694,63 @@ typedef w64_SteamPartyBeaconLocation_t w_SteamPartyBeaconLocation_t; typedef u64_SteamPartyBeaconLocation_t u_SteamPartyBeaconLocation_t; #endif +#pragma pack( push, 8 ) +struct w64_SteamUGCRequestUGCDetailsResult_t_160 +{ + w64_SteamUGCDetails_t_160 m_details; + int8_t m_bCachedData; + uint8_t __pad_9785[7]; +#ifdef __cplusplus + operator u64_SteamUGCRequestUGCDetailsResult_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCRequestUGCDetailsResult_t_160 +{ + u64_SteamUGCDetails_t_160 m_details; + int8_t m_bCachedData; + uint8_t __pad_9773[3]; +#ifdef __cplusplus + operator w64_SteamUGCRequestUGCDetailsResult_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCRequestUGCDetailsResult_t_160 +{ + w32_SteamUGCDetails_t_160 m_details; + int8_t m_bCachedData; + uint8_t __pad_9785[7]; +#ifdef __cplusplus + operator u32_SteamUGCRequestUGCDetailsResult_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCRequestUGCDetailsResult_t_160 +{ + u32_SteamUGCDetails_t_160 m_details; + int8_t m_bCachedData; + uint8_t __pad_9773[3]; +#ifdef __cplusplus + operator w32_SteamUGCRequestUGCDetailsResult_t_160() const; +#endif /* __cplusplus */ +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCRequestUGCDetailsResult_t_160 w_SteamUGCRequestUGCDetailsResult_t_160; +typedef u32_SteamUGCRequestUGCDetailsResult_t_160 u_SteamUGCRequestUGCDetailsResult_t_160; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCRequestUGCDetailsResult_t_160 w_SteamUGCRequestUGCDetailsResult_t_160; +typedef u64_SteamUGCRequestUGCDetailsResult_t_160 u_SteamUGCRequestUGCDetailsResult_t_160; +#endif + #pragma pack( push, 8 ) struct w64_SteamUGCRequestUGCDetailsResult_t_128x { diff --git a/lsteamclient/unix_private_generated.h b/lsteamclient/unix_private_generated.h index 980fcd8718..17cf815dab 100644 --- a/lsteamclient/unix_private_generated.h +++ b/lsteamclient/unix_private_generated.h @@ -4271,6 +4271,9 @@ struct u_ISteamApps_STEAMAPPS_INTERFACE_VERSION008 virtual int8_t BIsSubscribedFromFamilySharing( ) = 0; virtual int8_t BIsTimedTrial( uint32_t *, uint32_t * ) = 0; virtual int8_t SetDlcContext( uint32_t ) = 0; + virtual int32_t GetNumBetas( int32_t *, int32_t * ) = 0; + virtual int8_t GetBetaInfo( int32_t, uint32_t *, uint32_t *, char *, int32_t, char *, int32_t ) = 0; + virtual int8_t SetActiveBeta( const char * ) = 0; #endif /* __cplusplus */ }; @@ -7086,6 +7089,116 @@ struct u_ISteamClient_SteamClient021 #endif /* __cplusplus */ }; +struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 +{ +#ifdef __cplusplus + virtual uint64_t CreateQueryUserUGCRequest( uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t ) = 0; + virtual uint64_t CreateQueryAllUGCRequest( uint32_t, uint32_t, uint32_t, uint32_t, uint32_t ) = 0; + virtual uint64_t CreateQueryAllUGCRequest( uint32_t, uint32_t, uint32_t, uint32_t, const char * ) = 0; + virtual uint64_t CreateQueryUGCDetailsRequest( uint64_t *, uint32_t ) = 0; + virtual uint64_t SendQueryUGCRequest( uint64_t ) = 0; + virtual int8_t GetQueryUGCResult( uint64_t, uint32_t, u_SteamUGCDetails_t_160 * ) = 0; + virtual uint32_t GetQueryUGCNumTags( uint64_t, uint32_t ) = 0; + virtual int8_t GetQueryUGCTag( uint64_t, uint32_t, uint32_t, char *, uint32_t ) = 0; + virtual int8_t GetQueryUGCTagDisplayName( uint64_t, uint32_t, uint32_t, char *, uint32_t ) = 0; + virtual int8_t GetQueryUGCPreviewURL( uint64_t, uint32_t, char *, uint32_t ) = 0; + virtual int8_t GetQueryUGCMetadata( uint64_t, uint32_t, char *, uint32_t ) = 0; + virtual int8_t GetQueryUGCChildren( uint64_t, uint32_t, uint64_t *, uint32_t ) = 0; + virtual int8_t GetQueryUGCStatistic( uint64_t, uint32_t, uint32_t, uint64_t * ) = 0; + virtual uint32_t GetQueryUGCNumAdditionalPreviews( uint64_t, uint32_t ) = 0; + virtual int8_t GetQueryUGCAdditionalPreview( uint64_t, uint32_t, uint32_t, char *, uint32_t, char *, uint32_t, uint32_t * ) = 0; + virtual uint32_t GetQueryUGCNumKeyValueTags( uint64_t, uint32_t ) = 0; + virtual int8_t GetQueryUGCKeyValueTag( uint64_t, uint32_t, uint32_t, char *, uint32_t, char *, uint32_t ) = 0; + virtual int8_t GetQueryUGCKeyValueTag( uint64_t, uint32_t, const char *, char *, uint32_t ) = 0; + virtual uint32_t GetNumSupportedGameVersions( uint64_t, uint32_t ) = 0; + virtual int8_t GetSupportedGameVersionData( uint64_t, uint32_t, uint32_t, char *, char *, uint32_t ) = 0; + virtual uint32_t GetQueryUGCContentDescriptors( uint64_t, uint32_t, uint32_t *, uint32_t ) = 0; + virtual int8_t ReleaseQueryUGCRequest( uint64_t ) = 0; + virtual int8_t AddRequiredTag( uint64_t, const char * ) = 0; + virtual int8_t AddRequiredTagGroup( uint64_t, const u_SteamParamStringArray_t * ) = 0; + virtual int8_t AddExcludedTag( uint64_t, const char * ) = 0; + virtual int8_t SetReturnOnlyIDs( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnKeyValueTags( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnLongDescription( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnMetadata( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnChildren( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnAdditionalPreviews( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnTotalOnly( uint64_t, int8_t ) = 0; + virtual int8_t SetReturnPlaytimeStats( uint64_t, uint32_t ) = 0; + virtual int8_t SetLanguage( uint64_t, const char * ) = 0; + virtual int8_t SetAllowCachedResponse( uint64_t, uint32_t ) = 0; + virtual int8_t SetAdminQuery( uint64_t, int8_t ) = 0; + virtual int8_t SetCloudFileNameFilter( uint64_t, const char * ) = 0; + virtual int8_t SetMatchAnyTag( uint64_t, int8_t ) = 0; + virtual int8_t SetSearchText( uint64_t, const char * ) = 0; + virtual int8_t SetRankedByTrendDays( uint64_t, uint32_t ) = 0; + virtual int8_t SetTimeCreatedDateRange( uint64_t, uint32_t, uint32_t ) = 0; + virtual int8_t SetTimeUpdatedDateRange( uint64_t, uint32_t, uint32_t ) = 0; + virtual int8_t AddRequiredKeyValueTag( uint64_t, const char *, const char * ) = 0; + virtual uint64_t RequestUGCDetails( uint64_t, uint32_t ) = 0; + virtual uint64_t CreateItem( uint32_t, uint32_t ) = 0; + virtual uint64_t StartItemUpdate( uint32_t, uint64_t ) = 0; + virtual int8_t SetItemTitle( uint64_t, const char * ) = 0; + virtual int8_t SetItemDescription( uint64_t, const char * ) = 0; + virtual int8_t SetItemUpdateLanguage( uint64_t, const char * ) = 0; + virtual int8_t SetItemMetadata( uint64_t, const char * ) = 0; + virtual int8_t SetItemVisibility( uint64_t, uint32_t ) = 0; + virtual int8_t SetItemTags( uint64_t, const u_SteamParamStringArray_t *, int8_t ) = 0; + virtual int8_t SetItemContent( uint64_t, const char * ) = 0; + virtual int8_t SetItemPreview( uint64_t, const char * ) = 0; + virtual int8_t SetAllowLegacyUpload( uint64_t, int8_t ) = 0; + virtual int8_t RemoveAllItemKeyValueTags( uint64_t ) = 0; + virtual int8_t RemoveItemKeyValueTags( uint64_t, const char * ) = 0; + virtual int8_t AddItemKeyValueTag( uint64_t, const char *, const char * ) = 0; + virtual int8_t AddItemPreviewFile( uint64_t, const char *, uint32_t ) = 0; + virtual int8_t AddItemPreviewVideo( uint64_t, const char * ) = 0; + virtual int8_t UpdateItemPreviewFile( uint64_t, uint32_t, const char * ) = 0; + virtual int8_t UpdateItemPreviewVideo( uint64_t, uint32_t, const char * ) = 0; + virtual int8_t RemoveItemPreview( uint64_t, uint32_t ) = 0; + virtual int8_t AddContentDescriptor( uint64_t, uint32_t ) = 0; + virtual int8_t RemoveContentDescriptor( uint64_t, uint32_t ) = 0; + virtual int8_t SetRequiredGameVersions( uint64_t, const char *, const char * ) = 0; + virtual uint64_t SubmitItemUpdate( uint64_t, const char * ) = 0; + virtual uint32_t GetItemUpdateProgress( uint64_t, uint64_t *, uint64_t * ) = 0; + virtual uint64_t SetUserItemVote( uint64_t, int8_t ) = 0; + virtual uint64_t GetUserItemVote( uint64_t ) = 0; + virtual uint64_t AddItemToFavorites( uint32_t, uint64_t ) = 0; + virtual uint64_t RemoveItemFromFavorites( uint32_t, uint64_t ) = 0; + virtual uint64_t SubscribeItem( uint64_t ) = 0; + virtual uint64_t UnsubscribeItem( uint64_t ) = 0; + virtual uint32_t GetNumSubscribedItems( ) = 0; + virtual uint32_t GetSubscribedItems( uint64_t *, uint32_t ) = 0; + virtual uint32_t GetItemState( uint64_t ) = 0; + virtual int8_t GetItemInstallInfo( uint64_t, uint64_t *, char *, uint32_t, uint32_t * ) = 0; + virtual int8_t GetItemDownloadInfo( uint64_t, uint64_t *, uint64_t * ) = 0; + virtual int8_t DownloadItem( uint64_t, int8_t ) = 0; + virtual int8_t BInitWorkshopForGameServer( uint32_t, const char * ) = 0; + virtual void SuspendDownloads( int8_t ) = 0; + virtual uint64_t StartPlaytimeTracking( uint64_t *, uint32_t ) = 0; + virtual uint64_t StopPlaytimeTracking( uint64_t *, uint32_t ) = 0; + virtual uint64_t StopPlaytimeTrackingForAllItems( ) = 0; + virtual uint64_t AddDependency( uint64_t, uint64_t ) = 0; + virtual uint64_t RemoveDependency( uint64_t, uint64_t ) = 0; + virtual uint64_t AddAppDependency( uint64_t, uint32_t ) = 0; + virtual uint64_t RemoveAppDependency( uint64_t, uint32_t ) = 0; + virtual uint64_t GetAppDependencies( uint64_t ) = 0; + virtual uint64_t DeleteItem( uint64_t ) = 0; + virtual int8_t ShowWorkshopEULA( ) = 0; + virtual uint64_t GetWorkshopEULAStatus( ) = 0; + virtual uint32_t GetUserContentDescriptorPreferences( uint32_t *, uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 +{ +#ifdef __cplusplus + virtual void GetVideoURL( uint32_t ) = 0; + virtual int8_t IsBroadcasting( int32_t * ) = 0; + virtual void GetOPFSettings( uint32_t ) = 0; + virtual int8_t GetOPFStringForApp( uint32_t, char *, int32_t * ) = 0; +#endif /* __cplusplus */ +}; + NTSTATUS ISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001_GetNumInstalledApps( void * ); NTSTATUS ISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001_GetInstalledApps( void * ); @@ -7218,6 +7331,9 @@ NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetLaunchCommandLine( void * NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribedFromFamilySharing( void * ); NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsTimedTrial( void * ); NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext( void * ); +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas( void * ); +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo( void * ); +NTSTATUS ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta( void * ); NTSTATUS ISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001_GetAppOwnershipTicketData( void * ); NTSTATUS ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Init( void * ); NTSTATUS ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Shutdown( void * ); @@ -9305,6 +9421,100 @@ NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION018_DeleteItem( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION018_ShowWorkshopEULA( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetWorkshopEULAStatus( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetUserContentDescriptorPreferences( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus( void * ); +NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences( void * ); NTSTATUS ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_SendMethod( void * ); NTSTATUS ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseInfo( void * ); NTSTATUS ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseData( void * ); @@ -9663,6 +9873,10 @@ NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetVideoURL( void * ); NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V002_IsBroadcasting( void * ); NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFSettings( void * ); NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFStringForApp( void * ); +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL( void * ); +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting( void * ); +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings( void * ); +NTSTATUS ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp( void * ); NTSTATUS ISteamClient_SteamClient006_CreateSteamPipe( void * ); NTSTATUS ISteamClient_SteamClient006_BReleaseSteamPipe( void * ); NTSTATUS ISteamClient_SteamClient006_CreateGlobalUser( void * ); diff --git a/lsteamclient/unixlib_generated.cpp b/lsteamclient/unixlib_generated.cpp index c9ffef76d1..ee8511ad39 100644 --- a/lsteamclient/unixlib_generated.cpp +++ b/lsteamclient/unixlib_generated.cpp @@ -154,6 +154,9 @@ extern "C" const unixlib_entry_t __wine_unix_call_funcs[] = ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribedFromFamilySharing, ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsTimedTrial, ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext, + ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas, + ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo, + ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta, ISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001_GetAppOwnershipTicketData, ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Init, ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Shutdown, @@ -2241,6 +2244,100 @@ extern "C" const unixlib_entry_t __wine_unix_call_funcs[] = ISteamUGC_STEAMUGC_INTERFACE_VERSION018_ShowWorkshopEULA, ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetWorkshopEULAStatus, ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetUserContentDescriptorPreferences, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus, + ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences, ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_SendMethod, ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseInfo, ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseData, @@ -2599,6 +2696,10 @@ extern "C" const unixlib_entry_t __wine_unix_call_funcs[] = ISteamVideo_STEAMVIDEO_INTERFACE_V002_IsBroadcasting, ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFSettings, ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFStringForApp, + ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL, + ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting, + ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings, + ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp, ISteamClient_SteamClient006_CreateSteamPipe, ISteamClient_SteamClient006_BReleaseSteamPipe, ISteamClient_SteamClient006_CreateGlobalUser, @@ -7662,6 +7763,230 @@ C_ASSERT( sizeof(gameserveritem_t_099u().m_szServerName) >= 64 ); C_ASSERT( offsetof(gameserveritem_t_099u, m_szGameTags) == 236 ); C_ASSERT( sizeof(gameserveritem_t_099u().m_szGameTags) >= 128 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160) >= 9784 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_eResult) == 8 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_eFileType) == 12 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_hFile) == 9216 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_flScore) == 9764 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_flScore) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_unNumChildren) == 9768 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_unNumChildren) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_160, m_ulTotalFilesSize) == 9776 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_160().m_ulTotalFilesSize) >= 8 ); + +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160) >= 9772 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_eResult) == 8 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_eFileType) == 12 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_hFile) == 9208 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_flScore) == 9756 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_flScore) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_unNumChildren) == 9760 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_unNumChildren) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_160, m_ulTotalFilesSize) == 9764 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_160().m_ulTotalFilesSize) >= 8 ); + +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160) >= 9784 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_eResult) == 8 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_eFileType) == 12 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_hFile) == 9216 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_flScore) == 9764 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_flScore) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_unNumChildren) == 9768 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_unNumChildren) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_160, m_ulTotalFilesSize) == 9776 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_160().m_ulTotalFilesSize) >= 8 ); + +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160) >= 9772 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_eResult) == 8 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_eFileType) == 12 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_hFile) == 9208 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_flScore) == 9756 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_flScore) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_unNumChildren) == 9760 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_unNumChildren) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_160, m_ulTotalFilesSize) == 9764 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_160().m_ulTotalFilesSize) >= 8 ); + C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x) >= 9776 ); C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nPublishedFileId) == 0 ); C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nPublishedFileId) >= 8 ); @@ -8086,6 +8411,110 @@ C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_unVotesDown) >= 4 ); C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_flScore) == 9756 ); C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_flScore) >= 4 ); +static void SteamUGCDetails_t_160_u_from_w(void *dst, const void *src) +{ + u_SteamUGCDetails_t_160 *d = (u_SteamUGCDetails_t_160 *)dst; + const w_SteamUGCDetails_t_160 *s = (const w_SteamUGCDetails_t_160 *)src; + + d->m_nPublishedFileId = s->m_nPublishedFileId; + d->m_eResult = s->m_eResult; + d->m_eFileType = s->m_eFileType; + d->m_nCreatorAppID = s->m_nCreatorAppID; + d->m_nConsumerAppID = s->m_nConsumerAppID; + d->m_rgchTitle = s->m_rgchTitle; + d->m_rgchDescription = s->m_rgchDescription; + d->m_ulSteamIDOwner = s->m_ulSteamIDOwner; + d->m_rtimeCreated = s->m_rtimeCreated; + d->m_rtimeUpdated = s->m_rtimeUpdated; + d->m_rtimeAddedToUserList = s->m_rtimeAddedToUserList; + d->m_eVisibility = s->m_eVisibility; + d->m_bBanned = s->m_bBanned; + d->m_bAcceptedForUse = s->m_bAcceptedForUse; + d->m_bTagsTruncated = s->m_bTagsTruncated; + d->m_rgchTags = s->m_rgchTags; + d->m_hFile = s->m_hFile; + d->m_hPreviewFile = s->m_hPreviewFile; + d->m_pchFileName = s->m_pchFileName; + d->m_nFileSize = s->m_nFileSize; + d->m_nPreviewFileSize = s->m_nPreviewFileSize; + d->m_rgchURL = s->m_rgchURL; + d->m_unVotesUp = s->m_unVotesUp; + d->m_unVotesDown = s->m_unVotesDown; + d->m_flScore = s->m_flScore; + d->m_unNumChildren = s->m_unNumChildren; + d->m_ulTotalFilesSize = s->m_ulTotalFilesSize; +} +#ifdef __x86_64__ +w64_SteamUGCDetails_t_160::operator u64_SteamUGCDetails_t_160() const +{ + u64_SteamUGCDetails_t_160 ret; + SteamUGCDetails_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif + + +static void SteamUGCDetails_t_160_w_from_u(void *dst, const void *src) +{ + w_SteamUGCDetails_t_160 *d = (w_SteamUGCDetails_t_160 *)dst; + const u_SteamUGCDetails_t_160 *s = (const u_SteamUGCDetails_t_160 *)src; + + d->m_nPublishedFileId = s->m_nPublishedFileId; + d->m_eResult = s->m_eResult; + d->m_eFileType = s->m_eFileType; + d->m_nCreatorAppID = s->m_nCreatorAppID; + d->m_nConsumerAppID = s->m_nConsumerAppID; + d->m_rgchTitle = s->m_rgchTitle; + d->m_rgchDescription = s->m_rgchDescription; + d->m_ulSteamIDOwner = s->m_ulSteamIDOwner; + d->m_rtimeCreated = s->m_rtimeCreated; + d->m_rtimeUpdated = s->m_rtimeUpdated; + d->m_rtimeAddedToUserList = s->m_rtimeAddedToUserList; + d->m_eVisibility = s->m_eVisibility; + d->m_bBanned = s->m_bBanned; + d->m_bAcceptedForUse = s->m_bAcceptedForUse; + d->m_bTagsTruncated = s->m_bTagsTruncated; + d->m_rgchTags = s->m_rgchTags; + d->m_hFile = s->m_hFile; + d->m_hPreviewFile = s->m_hPreviewFile; + d->m_pchFileName = s->m_pchFileName; + d->m_nFileSize = s->m_nFileSize; + d->m_nPreviewFileSize = s->m_nPreviewFileSize; + d->m_rgchURL = s->m_rgchURL; + d->m_unVotesUp = s->m_unVotesUp; + d->m_unVotesDown = s->m_unVotesDown; + d->m_flScore = s->m_flScore; + d->m_unNumChildren = s->m_unNumChildren; + d->m_ulTotalFilesSize = s->m_ulTotalFilesSize; +} +#ifdef __x86_64__ +u64_SteamUGCDetails_t_160::operator w64_SteamUGCDetails_t_160() const +{ + w64_SteamUGCDetails_t_160 ret; + SteamUGCDetails_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + +#ifdef __i386__ +w32_SteamUGCDetails_t_160::operator u32_SteamUGCDetails_t_160() const +{ + u32_SteamUGCDetails_t_160 ret; + SteamUGCDetails_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif + + +#ifdef __i386__ +u32_SteamUGCDetails_t_160::operator w32_SteamUGCDetails_t_160() const +{ + w32_SteamUGCDetails_t_160 ret; + SteamUGCDetails_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + static void SteamUGCDetails_t_128x_u_from_w(void *dst, const void *src) { u_SteamUGCDetails_t_128x *d = (u_SteamUGCDetails_t_128x *)dst; @@ -12304,80 +12733,178 @@ u32_HTTPRequestHeadersReceived_t_121x::operator w32_HTTPRequestHeadersReceived_t } #endif -C_ASSERT( sizeof(w64_ItemInstalled_t) >= 16 ); -C_ASSERT( offsetof(w64_ItemInstalled_t, m_unAppID) == 0 ); -C_ASSERT( sizeof(w64_ItemInstalled_t().m_unAppID) >= 4 ); -C_ASSERT( offsetof(w64_ItemInstalled_t, m_nPublishedFileId) == 8 ); -C_ASSERT( sizeof(w64_ItemInstalled_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_160) >= 32 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_160, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_160().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_160, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_160, m_hLegacyContent) == 16 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_160().m_hLegacyContent) >= 8 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_160, m_unManifestID) == 24 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_160().m_unManifestID) >= 8 ); + +C_ASSERT( sizeof(u64_ItemInstalled_t_160) >= 28 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_160, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_160().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_160, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_160, m_hLegacyContent) == 12 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_160().m_hLegacyContent) >= 8 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_160, m_unManifestID) == 20 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_160().m_unManifestID) >= 8 ); + +C_ASSERT( sizeof(w32_ItemInstalled_t_160) >= 32 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_160, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_160().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_160, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_160, m_hLegacyContent) == 16 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_160().m_hLegacyContent) >= 8 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_160, m_unManifestID) == 24 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_160().m_unManifestID) >= 8 ); + +C_ASSERT( sizeof(u32_ItemInstalled_t_160) >= 28 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_160, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_160().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_160, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_160().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_160, m_hLegacyContent) == 12 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_160().m_hLegacyContent) >= 8 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_160, m_unManifestID) == 20 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_160().m_unManifestID) >= 8 ); + +C_ASSERT( sizeof(w64_ItemInstalled_t_130) >= 16 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_130, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_130().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_ItemInstalled_t_130, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_ItemInstalled_t_130().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_ItemInstalled_t_130) >= 12 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_130, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_130().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_ItemInstalled_t_130, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_ItemInstalled_t_130().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_ItemInstalled_t_130) >= 16 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_130, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_130().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_ItemInstalled_t_130, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_ItemInstalled_t_130().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_ItemInstalled_t_130) >= 12 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_130, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_130().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_ItemInstalled_t_130, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_ItemInstalled_t_130().m_nPublishedFileId) >= 8 ); + +static void ItemInstalled_t_160_u_from_w(void *dst, const void *src) +{ + u_ItemInstalled_t_160 *d = (u_ItemInstalled_t_160 *)dst; + const w_ItemInstalled_t_160 *s = (const w_ItemInstalled_t_160 *)src; -C_ASSERT( sizeof(u64_ItemInstalled_t) >= 12 ); -C_ASSERT( offsetof(u64_ItemInstalled_t, m_unAppID) == 0 ); -C_ASSERT( sizeof(u64_ItemInstalled_t().m_unAppID) >= 4 ); -C_ASSERT( offsetof(u64_ItemInstalled_t, m_nPublishedFileId) == 4 ); -C_ASSERT( sizeof(u64_ItemInstalled_t().m_nPublishedFileId) >= 8 ); + d->m_unAppID = s->m_unAppID; + d->m_nPublishedFileId = s->m_nPublishedFileId; + d->m_hLegacyContent = s->m_hLegacyContent; + d->m_unManifestID = s->m_unManifestID; +} +#ifdef __x86_64__ +w64_ItemInstalled_t_160::operator u64_ItemInstalled_t_160() const +{ + u64_ItemInstalled_t_160 ret; + ItemInstalled_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif -C_ASSERT( sizeof(w32_ItemInstalled_t) >= 16 ); -C_ASSERT( offsetof(w32_ItemInstalled_t, m_unAppID) == 0 ); -C_ASSERT( sizeof(w32_ItemInstalled_t().m_unAppID) >= 4 ); -C_ASSERT( offsetof(w32_ItemInstalled_t, m_nPublishedFileId) == 8 ); -C_ASSERT( sizeof(w32_ItemInstalled_t().m_nPublishedFileId) >= 8 ); -C_ASSERT( sizeof(u32_ItemInstalled_t) >= 12 ); -C_ASSERT( offsetof(u32_ItemInstalled_t, m_unAppID) == 0 ); -C_ASSERT( sizeof(u32_ItemInstalled_t().m_unAppID) >= 4 ); -C_ASSERT( offsetof(u32_ItemInstalled_t, m_nPublishedFileId) == 4 ); -C_ASSERT( sizeof(u32_ItemInstalled_t().m_nPublishedFileId) >= 8 ); +static void ItemInstalled_t_160_w_from_u(void *dst, const void *src) +{ + w_ItemInstalled_t_160 *d = (w_ItemInstalled_t_160 *)dst; + const u_ItemInstalled_t_160 *s = (const u_ItemInstalled_t_160 *)src; -static void ItemInstalled_t_u_from_w(void *dst, const void *src) + d->m_unAppID = s->m_unAppID; + d->m_nPublishedFileId = s->m_nPublishedFileId; + d->m_hLegacyContent = s->m_hLegacyContent; + d->m_unManifestID = s->m_unManifestID; +} +#ifdef __x86_64__ +u64_ItemInstalled_t_160::operator w64_ItemInstalled_t_160() const { - u_ItemInstalled_t *d = (u_ItemInstalled_t *)dst; - const w_ItemInstalled_t *s = (const w_ItemInstalled_t *)src; + w64_ItemInstalled_t_160 ret; + ItemInstalled_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + +#ifdef __i386__ +w32_ItemInstalled_t_160::operator u32_ItemInstalled_t_160() const +{ + u32_ItemInstalled_t_160 ret; + ItemInstalled_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif + + +#ifdef __i386__ +u32_ItemInstalled_t_160::operator w32_ItemInstalled_t_160() const +{ + w32_ItemInstalled_t_160 ret; + ItemInstalled_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + +static void ItemInstalled_t_130_u_from_w(void *dst, const void *src) +{ + u_ItemInstalled_t_130 *d = (u_ItemInstalled_t_130 *)dst; + const w_ItemInstalled_t_130 *s = (const w_ItemInstalled_t_130 *)src; d->m_unAppID = s->m_unAppID; d->m_nPublishedFileId = s->m_nPublishedFileId; } #ifdef __x86_64__ -w64_ItemInstalled_t::operator u64_ItemInstalled_t() const +w64_ItemInstalled_t_130::operator u64_ItemInstalled_t_130() const { - u64_ItemInstalled_t ret; - ItemInstalled_t_u_from_w((void *)&ret, (const void *)this); + u64_ItemInstalled_t_130 ret; + ItemInstalled_t_130_u_from_w((void *)&ret, (const void *)this); return ret; } #endif -static void ItemInstalled_t_w_from_u(void *dst, const void *src) +static void ItemInstalled_t_130_w_from_u(void *dst, const void *src) { - w_ItemInstalled_t *d = (w_ItemInstalled_t *)dst; - const u_ItemInstalled_t *s = (const u_ItemInstalled_t *)src; + w_ItemInstalled_t_130 *d = (w_ItemInstalled_t_130 *)dst; + const u_ItemInstalled_t_130 *s = (const u_ItemInstalled_t_130 *)src; d->m_unAppID = s->m_unAppID; d->m_nPublishedFileId = s->m_nPublishedFileId; } #ifdef __x86_64__ -u64_ItemInstalled_t::operator w64_ItemInstalled_t() const +u64_ItemInstalled_t_130::operator w64_ItemInstalled_t_130() const { - w64_ItemInstalled_t ret; - ItemInstalled_t_w_from_u((void *)&ret, (const void *)this); + w64_ItemInstalled_t_130 ret; + ItemInstalled_t_130_w_from_u((void *)&ret, (const void *)this); return ret; } #endif #ifdef __i386__ -w32_ItemInstalled_t::operator u32_ItemInstalled_t() const +w32_ItemInstalled_t_130::operator u32_ItemInstalled_t_130() const { - u32_ItemInstalled_t ret; - ItemInstalled_t_u_from_w((void *)&ret, (const void *)this); + u32_ItemInstalled_t_130 ret; + ItemInstalled_t_130_u_from_w((void *)&ret, (const void *)this); return ret; } #endif #ifdef __i386__ -u32_ItemInstalled_t::operator w32_ItemInstalled_t() const +u32_ItemInstalled_t_130::operator w32_ItemInstalled_t_130() const { - w32_ItemInstalled_t ret; - ItemInstalled_t_w_from_u((void *)&ret, (const void *)this); + w32_ItemInstalled_t_130 ret; + ItemInstalled_t_130_w_from_u((void *)&ret, (const void *)this); return ret; } #endif @@ -19805,6 +20332,30 @@ u32_SteamPartyBeaconLocation_t::operator w32_SteamPartyBeaconLocation_t() const } #endif +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_160) >= 9792 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_160, m_details) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_160().m_details) >= 9784 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_160, m_bCachedData) == 9784 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_160().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_160) >= 9776 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_160, m_details) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_160().m_details) >= 9772 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_160, m_bCachedData) == 9772 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_160().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_160) >= 9792 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_160, m_details) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_160().m_details) >= 9784 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_160, m_bCachedData) == 9784 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_160().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_160) >= 9776 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_160, m_details) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_160().m_details) >= 9772 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_160, m_bCachedData) == 9772 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_160().m_bCachedData) >= 1 ); + C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_128x) >= 9784 ); C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_128x, m_details) == 0 ); C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_128x().m_details) >= 9776 ); @@ -19869,6 +20420,60 @@ C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_126) >= 9760 ); C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_126, m_details) == 0 ); C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_126().m_details) >= 9760 ); +static void SteamUGCRequestUGCDetailsResult_t_160_u_from_w(void *dst, const void *src) +{ + u_SteamUGCRequestUGCDetailsResult_t_160 *d = (u_SteamUGCRequestUGCDetailsResult_t_160 *)dst; + const w_SteamUGCRequestUGCDetailsResult_t_160 *s = (const w_SteamUGCRequestUGCDetailsResult_t_160 *)src; + + d->m_details = s->m_details; + d->m_bCachedData = s->m_bCachedData; +} +#ifdef __x86_64__ +w64_SteamUGCRequestUGCDetailsResult_t_160::operator u64_SteamUGCRequestUGCDetailsResult_t_160() const +{ + u64_SteamUGCRequestUGCDetailsResult_t_160 ret; + SteamUGCRequestUGCDetailsResult_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif + + +static void SteamUGCRequestUGCDetailsResult_t_160_w_from_u(void *dst, const void *src) +{ + w_SteamUGCRequestUGCDetailsResult_t_160 *d = (w_SteamUGCRequestUGCDetailsResult_t_160 *)dst; + const u_SteamUGCRequestUGCDetailsResult_t_160 *s = (const u_SteamUGCRequestUGCDetailsResult_t_160 *)src; + + d->m_details = s->m_details; + d->m_bCachedData = s->m_bCachedData; +} +#ifdef __x86_64__ +u64_SteamUGCRequestUGCDetailsResult_t_160::operator w64_SteamUGCRequestUGCDetailsResult_t_160() const +{ + w64_SteamUGCRequestUGCDetailsResult_t_160 ret; + SteamUGCRequestUGCDetailsResult_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + +#ifdef __i386__ +w32_SteamUGCRequestUGCDetailsResult_t_160::operator u32_SteamUGCRequestUGCDetailsResult_t_160() const +{ + u32_SteamUGCRequestUGCDetailsResult_t_160 ret; + SteamUGCRequestUGCDetailsResult_t_160_u_from_w((void *)&ret, (const void *)this); + return ret; +} +#endif + + +#ifdef __i386__ +u32_SteamUGCRequestUGCDetailsResult_t_160::operator w32_SteamUGCRequestUGCDetailsResult_t_160() const +{ + w32_SteamUGCRequestUGCDetailsResult_t_160 ret; + SteamUGCRequestUGCDetailsResult_t_160_w_from_u((void *)&ret, (const void *)this); + return ret; +} +#endif + static void SteamUGCRequestUGCDetailsResult_t_128x_u_from_w(void *dst, const void *src) { u_SteamUGCRequestUGCDetailsResult_t_128x *d = (u_SteamUGCRequestUGCDetailsResult_t_128x *)dst; @@ -20120,221 +20725,225 @@ u32_SubmitPlayerResultResultCallback_t::operator w32_SubmitPlayerResultResultCal #ifdef __i386__ const struct callback_def callback_data[] = { - { 152, 159, 24, 16, MicroTxnAuthorizationResponse_t_123_w_from_u }, + { 152, 160, 24, 16, MicroTxnAuthorizationResponse_t_123_w_from_u }, /*{ 152, 122, 24, 16, MicroTxnAuthorizationResponse_t_109_w_from_u },*/ - { 209, 159, 40, 32, GSReputation_t_123_w_from_u }, + { 209, 160, 40, 32, GSReputation_t_123_w_from_u }, /*{ 209, 122, 40, 32, GSReputation_t_108_w_from_u },*/ - { 513, 159, 16, 12, LobbyCreated_t_123_w_from_u }, + { 513, 160, 16, 12, LobbyCreated_t_123_w_from_u }, /*{ 513, 122, 16, 12, LobbyCreated_t_099u_w_from_u },*/ - { 1023, 159, 40, 36, FileDetailsResult_t_w_from_u }, - { 1106, 159, 32, 28, LeaderboardScoreUploaded_t_123_w_from_u }, + { 1023, 160, 40, 36, FileDetailsResult_t_w_from_u }, + { 1106, 160, 32, 28, LeaderboardScoreUploaded_t_123_w_from_u }, /*{ 1106, 122, 32, 28, LeaderboardScoreUploaded_t_104_w_from_u },*/ - { 1111, 159, 16, 12, LeaderboardUGCSet_t_123_w_from_u }, + { 1111, 160, 16, 12, LeaderboardUGCSet_t_123_w_from_u }, /*{ 1111, 122, 16, 12, LeaderboardUGCSet_t_111x_w_from_u },*/ - { 1112, 159, 24, 20, PS3TrophiesInstalled_t_123_w_from_u }, + { 1112, 160, 24, 20, PS3TrophiesInstalled_t_123_w_from_u }, /*{ 1112, 122, 24, 20, PS3TrophiesInstalled_t_112x_w_from_u },*/ - { 1221, 159, 712, 704, SteamNetConnectionStatusChangedCallback_t_153a_w_from_u }, + { 1221, 160, 712, 704, SteamNetConnectionStatusChangedCallback_t_153a_w_from_u }, /*{ 1221, 152, 712, 704, SteamNetConnectionStatusChangedCallback_t_144_w_from_u },*/ { 1221, 151, 584, 576, SteamNetConnectionStatusChangedCallback_t_151_w_from_u }, { 1303, 151, 288, 280, RemoteStorageAppSyncProgress_t_123_w_from_u }, /*{ 1303, 122, 288, 280, RemoteStorageAppSyncProgress_t_111x_w_from_u },*/ - { 1307, 159, 280, 272, RemoteStorageFileShareResult_t_128x_w_from_u }, + { 1307, 160, 280, 272, RemoteStorageFileShareResult_t_128x_w_from_u }, { 1307, 128, 16, 12, RemoteStorageFileShareResult_t_123_w_from_u }, /*{ 1307, 122, 16, 12, RemoteStorageFileShareResult_t_111x_w_from_u },*/ { 1308, 116, 40, 32, RemoteStorageDownloadUGCResult_t_111x_w_from_u }, - { 1309, 159, 24, 16, RemoteStoragePublishFileResult_t_125_w_from_u }, + { 1309, 160, 24, 16, RemoteStoragePublishFileResult_t_125_w_from_u }, { 1309, 124, 16, 12, RemoteStoragePublishFileResult_t_123_w_from_u }, /*{ 1309, 122, 16, 12, RemoteStoragePublishFileResult_t_116x_w_from_u },*/ { 1310, 117, 1744, 1732, RemoteStorageGetPublishedFileDetailsResult_t_116x_w_from_u }, - { 1311, 159, 16, 12, RemoteStorageDeletePublishedFileResult_t_123_w_from_u }, + { 1311, 160, 16, 12, RemoteStorageDeletePublishedFileResult_t_123_w_from_u }, /*{ 1311, 122, 16, 12, RemoteStorageDeletePublishedFileResult_t_116x_w_from_u },*/ - { 1312, 159, 416, 412, RemoteStorageEnumerateUserPublishedFilesResult_t_123_w_from_u }, + { 1312, 160, 416, 412, RemoteStorageEnumerateUserPublishedFilesResult_t_123_w_from_u }, /*{ 1312, 122, 416, 412, RemoteStorageEnumerateUserPublishedFilesResult_t_116x_w_from_u },*/ - { 1313, 159, 16, 12, RemoteStorageSubscribePublishedFileResult_t_123_w_from_u }, + { 1313, 160, 16, 12, RemoteStorageSubscribePublishedFileResult_t_123_w_from_u }, { 1313, 122, 4, 4, nullptr }, - { 1314, 159, 616, 612, RemoteStorageEnumerateUserSubscribedFilesResult_t_123_w_from_u }, + { 1314, 160, 616, 612, RemoteStorageEnumerateUserSubscribedFilesResult_t_123_w_from_u }, /*{ 1314, 122, 616, 612, RemoteStorageEnumerateUserSubscribedFilesResult_t_116x_w_from_u },*/ - { 1315, 159, 16, 12, RemoteStorageUnsubscribePublishedFileResult_t_123_w_from_u }, + { 1315, 160, 16, 12, RemoteStorageUnsubscribePublishedFileResult_t_123_w_from_u }, { 1315, 122, 4, 4, nullptr }, - { 1316, 159, 24, 16, RemoteStorageUpdatePublishedFileResult_t_125_w_from_u }, + { 1316, 160, 24, 16, RemoteStorageUpdatePublishedFileResult_t_125_w_from_u }, { 1316, 124, 16, 12, RemoteStorageUpdatePublishedFileResult_t_123_w_from_u }, /*{ 1316, 122, 16, 12, RemoteStorageUpdatePublishedFileResult_t_116x_w_from_u },*/ - { 1317, 159, 296, 288, RemoteStorageDownloadUGCResult_t_123_w_from_u }, + { 1317, 160, 296, 288, RemoteStorageDownloadUGCResult_t_123_w_from_u }, /*{ 1317, 122, 296, 288, RemoteStorageDownloadUGCResult_t_116x_w_from_u },*/ - { 1318, 159, 9760, 9748, RemoteStorageGetPublishedFileDetailsResult_t_126_w_from_u }, + { 1318, 160, 9760, 9748, RemoteStorageGetPublishedFileDetailsResult_t_126_w_from_u }, { 1318, 125, 9752, 9744, RemoteStorageGetPublishedFileDetailsResult_t_123_w_from_u }, /*{ 1318, 122, 9752, 9744, RemoteStorageGetPublishedFileDetailsResult_t_119x_w_from_u },*/ { 1318, 119, 9752, 9740, RemoteStorageGetPublishedFileDetailsResult_t_119_w_from_u }, { 1318, 118, 9496, 9484, RemoteStorageGetPublishedFileDetailsResult_t_118_w_from_u }, - { 1319, 159, 624, 620, RemoteStorageEnumerateWorkshopFilesResult_t_125_w_from_u }, + { 1319, 160, 624, 620, RemoteStorageEnumerateWorkshopFilesResult_t_125_w_from_u }, { 1319, 124, 616, 612, RemoteStorageEnumerateWorkshopFilesResult_t_123_w_from_u }, /*{ 1319, 122, 616, 612, RemoteStorageEnumerateWorkshopFilesResult_t_119_w_from_u },*/ - { 1320, 159, 32, 28, RemoteStorageGetPublishedItemVoteDetailsResult_t_123_w_from_u }, + { 1320, 160, 32, 28, RemoteStorageGetPublishedItemVoteDetailsResult_t_123_w_from_u }, /*{ 1320, 122, 32, 28, RemoteStorageGetPublishedItemVoteDetailsResult_t_119_w_from_u },*/ - { 1324, 159, 16, 12, RemoteStorageUpdateUserPublishedItemVoteResult_t_123_w_from_u }, + { 1324, 160, 16, 12, RemoteStorageUpdateUserPublishedItemVoteResult_t_123_w_from_u }, /*{ 1324, 122, 16, 12, RemoteStorageUpdateUserPublishedItemVoteResult_t_119_w_from_u },*/ - { 1325, 159, 24, 16, RemoteStorageUserVoteDetails_t_123_w_from_u }, + { 1325, 160, 24, 16, RemoteStorageUserVoteDetails_t_123_w_from_u }, /*{ 1325, 122, 24, 16, RemoteStorageUserVoteDetails_t_119_w_from_u },*/ - { 1326, 159, 416, 412, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123_w_from_u }, + { 1326, 160, 416, 412, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123_w_from_u }, /*{ 1326, 122, 416, 412, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119_w_from_u },*/ - { 1327, 159, 24, 16, RemoteStorageSetUserPublishedFileActionResult_t_123_w_from_u }, + { 1327, 160, 24, 16, RemoteStorageSetUserPublishedFileActionResult_t_123_w_from_u }, /*{ 1327, 122, 24, 16, RemoteStorageSetUserPublishedFileActionResult_t_119_w_from_u },*/ - { 1330, 159, 24, 20, RemoteStoragePublishedFileUpdated_t_w_from_u }, - { 2101, 159, 32, 24, HTTPRequestCompleted_t_132x_w_from_u }, + { 1330, 160, 24, 20, RemoteStoragePublishedFileUpdated_t_w_from_u }, + { 2101, 160, 32, 24, HTTPRequestCompleted_t_132x_w_from_u }, { 2101, 132, 24, 20, HTTPRequestCompleted_t_123_w_from_u }, /*{ 2101, 122, 24, 20, HTTPRequestCompleted_t_115_w_from_u },*/ - { 2102, 159, 16, 12, HTTPRequestHeadersReceived_t_123_w_from_u }, + { 2102, 160, 16, 12, HTTPRequestHeadersReceived_t_123_w_from_u }, /*{ 2102, 122, 16, 12, HTTPRequestHeadersReceived_t_121x_w_from_u },*/ - { 2103, 159, 24, 20, HTTPRequestDataReceived_t_123_w_from_u }, + { 2103, 160, 24, 20, HTTPRequestDataReceived_t_123_w_from_u }, /*{ 2103, 122, 24, 20, HTTPRequestDataReceived_t_121x_w_from_u },*/ - { 2803, 159, 40, 32, SteamInputConfigurationLoaded_t_w_from_u }, - { 2804, 159, 32, 24, SteamInputGamepadSlotChange_t_w_from_u }, + { 2803, 160, 40, 32, SteamInputConfigurationLoaded_t_w_from_u }, + { 2804, 160, 32, 24, SteamInputGamepadSlotChange_t_w_from_u }, + { 3402, 160, 9792, 9776, SteamUGCRequestUGCDetailsResult_t_160_w_from_u }, { 3402, 159, 9784, 9768, SteamUGCRequestUGCDetailsResult_t_128x_w_from_u }, { 3402, 129, 9776, 9764, SteamUGCRequestUGCDetailsResult_t_129_w_from_u }, { 3402, 128, 9768, 9760, SteamUGCRequestUGCDetailsResult_t_126_w_from_u }, - { 3403, 159, 24, 16, CreateItemResult_t_w_from_u }, - { 3405, 159, 16, 12, ItemInstalled_t_w_from_u }, - { 3406, 159, 24, 16, DownloadItemResult_t_w_from_u }, - { 3412, 159, 24, 20, AddUGCDependencyResult_t_w_from_u }, - { 3413, 159, 24, 20, RemoveUGCDependencyResult_t_w_from_u }, - { 3414, 159, 24, 16, AddAppDependencyResult_t_w_from_u }, - { 3415, 159, 24, 16, RemoveAppDependencyResult_t_w_from_u }, - { 3416, 159, 152, 148, GetAppDependenciesResult_t_w_from_u }, - { 3417, 159, 16, 12, DeleteItemResult_t_w_from_u }, - { 4502, 159, 48, 48, HTML_NeedsPaint_t_w_from_u }, - { 4503, 159, 20, 20, HTML_StartRequest_t_w_from_u }, - { 4505, 159, 24, 24, HTML_URLChanged_t_w_from_u }, - { 4506, 159, 12, 12, HTML_FinishedRequest_t_w_from_u }, - { 4507, 159, 8, 8, HTML_OpenLinkInNewTab_t_w_from_u }, - { 4508, 159, 8, 8, HTML_ChangedTitle_t_w_from_u }, - { 4513, 159, 20, 20, HTML_LinkAtPosition_t_w_from_u }, - { 4514, 159, 8, 8, HTML_JSAlert_t_w_from_u }, - { 4515, 159, 8, 8, HTML_JSConfirm_t_w_from_u }, - { 4516, 159, 12, 12, HTML_FileOpenDialog_t_w_from_u }, + { 3403, 160, 24, 16, CreateItemResult_t_w_from_u }, + { 3405, 160, 32, 28, ItemInstalled_t_160_w_from_u }, + { 3405, 159, 16, 12, ItemInstalled_t_130_w_from_u }, + { 3406, 160, 24, 16, DownloadItemResult_t_w_from_u }, + { 3412, 160, 24, 20, AddUGCDependencyResult_t_w_from_u }, + { 3413, 160, 24, 20, RemoveUGCDependencyResult_t_w_from_u }, + { 3414, 160, 24, 16, AddAppDependencyResult_t_w_from_u }, + { 3415, 160, 24, 16, RemoveAppDependencyResult_t_w_from_u }, + { 3416, 160, 152, 148, GetAppDependenciesResult_t_w_from_u }, + { 3417, 160, 16, 12, DeleteItemResult_t_w_from_u }, + { 4502, 160, 48, 48, HTML_NeedsPaint_t_w_from_u }, + { 4503, 160, 20, 20, HTML_StartRequest_t_w_from_u }, + { 4505, 160, 24, 24, HTML_URLChanged_t_w_from_u }, + { 4506, 160, 12, 12, HTML_FinishedRequest_t_w_from_u }, + { 4507, 160, 8, 8, HTML_OpenLinkInNewTab_t_w_from_u }, + { 4508, 160, 8, 8, HTML_ChangedTitle_t_w_from_u }, + { 4513, 160, 20, 20, HTML_LinkAtPosition_t_w_from_u }, + { 4514, 160, 8, 8, HTML_JSAlert_t_w_from_u }, + { 4515, 160, 8, 8, HTML_JSConfirm_t_w_from_u }, + { 4516, 160, 12, 12, HTML_FileOpenDialog_t_w_from_u }, { 4517, 132, 16, 16, HTML_ComboNeedsPaint_t_w_from_u }, - { 4521, 159, 28, 28, HTML_NewWindow_t_132x_w_from_u }, + { 4521, 160, 28, 28, HTML_NewWindow_t_132x_w_from_u }, { 4521, 132, 24, 24, HTML_NewWindow_t_130x_w_from_u }, - { 4523, 159, 8, 8, HTML_StatusText_t_w_from_u }, - { 4524, 159, 8, 8, HTML_ShowToolTip_t_w_from_u }, - { 4525, 159, 8, 8, HTML_UpdateToolTip_t_w_from_u }, - { 4704, 159, 24, 20, SteamInventoryStartPurchaseResult_t_w_from_u }, - { 5211, 159, 16, 12, RequestPlayersForGameProgressCallback_t_w_from_u }, - { 5212, 159, 64, 56, RequestPlayersForGameResultCallback_t_w_from_u }, - { 5213, 159, 24, 20, RequestPlayersForGameFinalResultCallback_t_w_from_u }, - { 5214, 159, 24, 20, SubmitPlayerResultResultCallback_t_w_from_u }, - { 5215, 159, 16, 12, EndGameResultCallback_t_w_from_u }, - { 5301, 159, 280, 276, JoinPartyCallback_t_w_from_u }, - { 5302, 159, 16, 12, CreateBeaconCallback_t_w_from_u }, + { 4523, 160, 8, 8, HTML_StatusText_t_w_from_u }, + { 4524, 160, 8, 8, HTML_ShowToolTip_t_w_from_u }, + { 4525, 160, 8, 8, HTML_UpdateToolTip_t_w_from_u }, + { 4704, 160, 24, 20, SteamInventoryStartPurchaseResult_t_w_from_u }, + { 5211, 160, 16, 12, RequestPlayersForGameProgressCallback_t_w_from_u }, + { 5212, 160, 64, 56, RequestPlayersForGameResultCallback_t_w_from_u }, + { 5213, 160, 24, 20, RequestPlayersForGameFinalResultCallback_t_w_from_u }, + { 5214, 160, 24, 20, SubmitPlayerResultResultCallback_t_w_from_u }, + { 5215, 160, 16, 12, EndGameResultCallback_t_w_from_u }, + { 5301, 160, 280, 276, JoinPartyCallback_t_w_from_u }, + { 5302, 160, 16, 12, CreateBeaconCallback_t_w_from_u }, }; #endif #ifdef __x86_64__ const struct callback_def callback_data[] = { - { 152, 159, 24, 16, MicroTxnAuthorizationResponse_t_123_w_from_u }, + { 152, 160, 24, 16, MicroTxnAuthorizationResponse_t_123_w_from_u }, { 152, 122, 24, 24, MicroTxnAuthorizationResponse_t_109_w_from_u }, - { 209, 159, 40, 32, GSReputation_t_123_w_from_u }, + { 209, 160, 40, 32, GSReputation_t_123_w_from_u }, { 209, 122, 40, 40, GSReputation_t_108_w_from_u }, - { 513, 159, 16, 12, LobbyCreated_t_123_w_from_u }, + { 513, 160, 16, 12, LobbyCreated_t_123_w_from_u }, { 513, 122, 16, 16, LobbyCreated_t_099u_w_from_u }, - { 1023, 159, 40, 36, FileDetailsResult_t_w_from_u }, - { 1106, 159, 32, 28, LeaderboardScoreUploaded_t_123_w_from_u }, + { 1023, 160, 40, 36, FileDetailsResult_t_w_from_u }, + { 1106, 160, 32, 28, LeaderboardScoreUploaded_t_123_w_from_u }, { 1106, 122, 32, 32, LeaderboardScoreUploaded_t_104_w_from_u }, - { 1111, 159, 16, 12, LeaderboardUGCSet_t_123_w_from_u }, + { 1111, 160, 16, 12, LeaderboardUGCSet_t_123_w_from_u }, { 1111, 122, 16, 16, LeaderboardUGCSet_t_111x_w_from_u }, - { 1112, 159, 24, 20, PS3TrophiesInstalled_t_123_w_from_u }, + { 1112, 160, 24, 20, PS3TrophiesInstalled_t_123_w_from_u }, { 1112, 122, 24, 24, PS3TrophiesInstalled_t_112x_w_from_u }, - { 1221, 159, 712, 704, SteamNetConnectionStatusChangedCallback_t_153a_w_from_u }, + { 1221, 160, 712, 704, SteamNetConnectionStatusChangedCallback_t_153a_w_from_u }, /*{ 1221, 152, 712, 704, SteamNetConnectionStatusChangedCallback_t_144_w_from_u },*/ { 1221, 151, 584, 576, SteamNetConnectionStatusChangedCallback_t_151_w_from_u }, { 1303, 151, 288, 280, RemoteStorageAppSyncProgress_t_123_w_from_u }, { 1303, 122, 288, 288, RemoteStorageAppSyncProgress_t_111x_w_from_u }, - { 1307, 159, 280, 272, RemoteStorageFileShareResult_t_128x_w_from_u }, + { 1307, 160, 280, 272, RemoteStorageFileShareResult_t_128x_w_from_u }, { 1307, 128, 16, 12, RemoteStorageFileShareResult_t_123_w_from_u }, { 1307, 122, 16, 16, RemoteStorageFileShareResult_t_111x_w_from_u }, { 1308, 116, 40, 40, RemoteStorageDownloadUGCResult_t_111x_w_from_u }, - { 1309, 159, 24, 16, RemoteStoragePublishFileResult_t_125_w_from_u }, + { 1309, 160, 24, 16, RemoteStoragePublishFileResult_t_125_w_from_u }, { 1309, 124, 16, 12, RemoteStoragePublishFileResult_t_123_w_from_u }, { 1309, 122, 16, 16, RemoteStoragePublishFileResult_t_116x_w_from_u }, { 1310, 117, 1744, 1744, RemoteStorageGetPublishedFileDetailsResult_t_116x_w_from_u }, - { 1311, 159, 16, 12, RemoteStorageDeletePublishedFileResult_t_123_w_from_u }, + { 1311, 160, 16, 12, RemoteStorageDeletePublishedFileResult_t_123_w_from_u }, { 1311, 122, 16, 16, RemoteStorageDeletePublishedFileResult_t_116x_w_from_u }, - { 1312, 159, 416, 412, RemoteStorageEnumerateUserPublishedFilesResult_t_123_w_from_u }, + { 1312, 160, 416, 412, RemoteStorageEnumerateUserPublishedFilesResult_t_123_w_from_u }, { 1312, 122, 416, 416, RemoteStorageEnumerateUserPublishedFilesResult_t_116x_w_from_u }, - { 1313, 159, 16, 12, RemoteStorageSubscribePublishedFileResult_t_123_w_from_u }, + { 1313, 160, 16, 12, RemoteStorageSubscribePublishedFileResult_t_123_w_from_u }, { 1313, 122, 4, 4, nullptr }, - { 1314, 159, 616, 612, RemoteStorageEnumerateUserSubscribedFilesResult_t_123_w_from_u }, + { 1314, 160, 616, 612, RemoteStorageEnumerateUserSubscribedFilesResult_t_123_w_from_u }, { 1314, 122, 616, 616, RemoteStorageEnumerateUserSubscribedFilesResult_t_116x_w_from_u }, - { 1315, 159, 16, 12, RemoteStorageUnsubscribePublishedFileResult_t_123_w_from_u }, + { 1315, 160, 16, 12, RemoteStorageUnsubscribePublishedFileResult_t_123_w_from_u }, { 1315, 122, 4, 4, nullptr }, - { 1316, 159, 24, 16, RemoteStorageUpdatePublishedFileResult_t_125_w_from_u }, + { 1316, 160, 24, 16, RemoteStorageUpdatePublishedFileResult_t_125_w_from_u }, { 1316, 124, 16, 12, RemoteStorageUpdatePublishedFileResult_t_123_w_from_u }, { 1316, 122, 16, 16, RemoteStorageUpdatePublishedFileResult_t_116x_w_from_u }, - { 1317, 159, 296, 288, RemoteStorageDownloadUGCResult_t_123_w_from_u }, + { 1317, 160, 296, 288, RemoteStorageDownloadUGCResult_t_123_w_from_u }, { 1317, 122, 296, 296, RemoteStorageDownloadUGCResult_t_116x_w_from_u }, - { 1318, 159, 9760, 9748, RemoteStorageGetPublishedFileDetailsResult_t_126_w_from_u }, + { 1318, 160, 9760, 9748, RemoteStorageGetPublishedFileDetailsResult_t_126_w_from_u }, { 1318, 125, 9752, 9744, RemoteStorageGetPublishedFileDetailsResult_t_123_w_from_u }, { 1318, 122, 9752, 9752, RemoteStorageGetPublishedFileDetailsResult_t_119x_w_from_u }, /*{ 1318, 119, 9752, 9752, RemoteStorageGetPublishedFileDetailsResult_t_119_w_from_u },*/ { 1318, 118, 9496, 9496, RemoteStorageGetPublishedFileDetailsResult_t_118_w_from_u }, - { 1319, 159, 624, 620, RemoteStorageEnumerateWorkshopFilesResult_t_125_w_from_u }, + { 1319, 160, 624, 620, RemoteStorageEnumerateWorkshopFilesResult_t_125_w_from_u }, { 1319, 124, 616, 612, RemoteStorageEnumerateWorkshopFilesResult_t_123_w_from_u }, { 1319, 122, 616, 616, RemoteStorageEnumerateWorkshopFilesResult_t_119_w_from_u }, - { 1320, 159, 32, 28, RemoteStorageGetPublishedItemVoteDetailsResult_t_123_w_from_u }, + { 1320, 160, 32, 28, RemoteStorageGetPublishedItemVoteDetailsResult_t_123_w_from_u }, { 1320, 122, 32, 32, RemoteStorageGetPublishedItemVoteDetailsResult_t_119_w_from_u }, - { 1324, 159, 16, 12, RemoteStorageUpdateUserPublishedItemVoteResult_t_123_w_from_u }, + { 1324, 160, 16, 12, RemoteStorageUpdateUserPublishedItemVoteResult_t_123_w_from_u }, { 1324, 122, 16, 16, RemoteStorageUpdateUserPublishedItemVoteResult_t_119_w_from_u }, - { 1325, 159, 24, 16, RemoteStorageUserVoteDetails_t_123_w_from_u }, + { 1325, 160, 24, 16, RemoteStorageUserVoteDetails_t_123_w_from_u }, { 1325, 122, 24, 24, RemoteStorageUserVoteDetails_t_119_w_from_u }, - { 1326, 159, 416, 412, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123_w_from_u }, + { 1326, 160, 416, 412, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123_w_from_u }, { 1326, 122, 416, 416, RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119_w_from_u }, - { 1327, 159, 24, 16, RemoteStorageSetUserPublishedFileActionResult_t_123_w_from_u }, + { 1327, 160, 24, 16, RemoteStorageSetUserPublishedFileActionResult_t_123_w_from_u }, { 1327, 122, 24, 24, RemoteStorageSetUserPublishedFileActionResult_t_119_w_from_u }, - { 1330, 159, 24, 20, RemoteStoragePublishedFileUpdated_t_w_from_u }, - { 2101, 159, 32, 24, HTTPRequestCompleted_t_132x_w_from_u }, + { 1330, 160, 24, 20, RemoteStoragePublishedFileUpdated_t_w_from_u }, + { 2101, 160, 32, 24, HTTPRequestCompleted_t_132x_w_from_u }, { 2101, 132, 24, 20, HTTPRequestCompleted_t_123_w_from_u }, { 2101, 122, 24, 24, HTTPRequestCompleted_t_115_w_from_u }, - { 2102, 159, 16, 12, HTTPRequestHeadersReceived_t_123_w_from_u }, + { 2102, 160, 16, 12, HTTPRequestHeadersReceived_t_123_w_from_u }, { 2102, 122, 16, 16, HTTPRequestHeadersReceived_t_121x_w_from_u }, - { 2103, 159, 24, 20, HTTPRequestDataReceived_t_123_w_from_u }, + { 2103, 160, 24, 20, HTTPRequestDataReceived_t_123_w_from_u }, { 2103, 122, 24, 24, HTTPRequestDataReceived_t_121x_w_from_u }, - { 2803, 159, 40, 32, SteamInputConfigurationLoaded_t_w_from_u }, - { 2804, 159, 32, 24, SteamInputGamepadSlotChange_t_w_from_u }, + { 2803, 160, 40, 32, SteamInputConfigurationLoaded_t_w_from_u }, + { 2804, 160, 32, 24, SteamInputGamepadSlotChange_t_w_from_u }, + { 3402, 160, 9792, 9776, SteamUGCRequestUGCDetailsResult_t_160_w_from_u }, { 3402, 159, 9784, 9768, SteamUGCRequestUGCDetailsResult_t_128x_w_from_u }, { 3402, 129, 9776, 9764, SteamUGCRequestUGCDetailsResult_t_129_w_from_u }, { 3402, 128, 9768, 9760, SteamUGCRequestUGCDetailsResult_t_126_w_from_u }, - { 3403, 159, 24, 16, CreateItemResult_t_w_from_u }, - { 3405, 159, 16, 12, ItemInstalled_t_w_from_u }, - { 3406, 159, 24, 16, DownloadItemResult_t_w_from_u }, - { 3412, 159, 24, 20, AddUGCDependencyResult_t_w_from_u }, - { 3413, 159, 24, 20, RemoveUGCDependencyResult_t_w_from_u }, - { 3414, 159, 24, 16, AddAppDependencyResult_t_w_from_u }, - { 3415, 159, 24, 16, RemoveAppDependencyResult_t_w_from_u }, - { 3416, 159, 152, 148, GetAppDependenciesResult_t_w_from_u }, - { 3417, 159, 16, 12, DeleteItemResult_t_w_from_u }, - { 4502, 159, 56, 52, HTML_NeedsPaint_t_w_from_u }, - { 4503, 159, 40, 32, HTML_StartRequest_t_w_from_u }, - { 4505, 159, 48, 36, HTML_URLChanged_t_w_from_u }, - { 4506, 159, 24, 20, HTML_FinishedRequest_t_w_from_u }, - { 4507, 159, 16, 12, HTML_OpenLinkInNewTab_t_w_from_u }, - { 4508, 159, 16, 12, HTML_ChangedTitle_t_w_from_u }, - { 4513, 159, 32, 24, HTML_LinkAtPosition_t_w_from_u }, - { 4514, 159, 16, 12, HTML_JSAlert_t_w_from_u }, - { 4515, 159, 16, 12, HTML_JSConfirm_t_w_from_u }, - { 4516, 159, 24, 20, HTML_FileOpenDialog_t_w_from_u }, + { 3403, 160, 24, 16, CreateItemResult_t_w_from_u }, + { 3405, 160, 32, 28, ItemInstalled_t_160_w_from_u }, + { 3405, 159, 16, 12, ItemInstalled_t_130_w_from_u }, + { 3406, 160, 24, 16, DownloadItemResult_t_w_from_u }, + { 3412, 160, 24, 20, AddUGCDependencyResult_t_w_from_u }, + { 3413, 160, 24, 20, RemoveUGCDependencyResult_t_w_from_u }, + { 3414, 160, 24, 16, AddAppDependencyResult_t_w_from_u }, + { 3415, 160, 24, 16, RemoveAppDependencyResult_t_w_from_u }, + { 3416, 160, 152, 148, GetAppDependenciesResult_t_w_from_u }, + { 3417, 160, 16, 12, DeleteItemResult_t_w_from_u }, + { 4502, 160, 56, 52, HTML_NeedsPaint_t_w_from_u }, + { 4503, 160, 40, 32, HTML_StartRequest_t_w_from_u }, + { 4505, 160, 48, 36, HTML_URLChanged_t_w_from_u }, + { 4506, 160, 24, 20, HTML_FinishedRequest_t_w_from_u }, + { 4507, 160, 16, 12, HTML_OpenLinkInNewTab_t_w_from_u }, + { 4508, 160, 16, 12, HTML_ChangedTitle_t_w_from_u }, + { 4513, 160, 32, 24, HTML_LinkAtPosition_t_w_from_u }, + { 4514, 160, 16, 12, HTML_JSAlert_t_w_from_u }, + { 4515, 160, 16, 12, HTML_JSConfirm_t_w_from_u }, + { 4516, 160, 24, 20, HTML_FileOpenDialog_t_w_from_u }, { 4517, 132, 24, 20, HTML_ComboNeedsPaint_t_w_from_u }, - { 4521, 159, 40, 32, HTML_NewWindow_t_132x_w_from_u }, + { 4521, 160, 40, 32, HTML_NewWindow_t_132x_w_from_u }, { 4521, 132, 32, 28, HTML_NewWindow_t_130x_w_from_u }, - { 4523, 159, 16, 12, HTML_StatusText_t_w_from_u }, - { 4524, 159, 16, 12, HTML_ShowToolTip_t_w_from_u }, - { 4525, 159, 16, 12, HTML_UpdateToolTip_t_w_from_u }, - { 4704, 159, 24, 20, SteamInventoryStartPurchaseResult_t_w_from_u }, - { 5211, 159, 16, 12, RequestPlayersForGameProgressCallback_t_w_from_u }, - { 5212, 159, 64, 56, RequestPlayersForGameResultCallback_t_w_from_u }, - { 5213, 159, 24, 20, RequestPlayersForGameFinalResultCallback_t_w_from_u }, - { 5214, 159, 24, 20, SubmitPlayerResultResultCallback_t_w_from_u }, - { 5215, 159, 16, 12, EndGameResultCallback_t_w_from_u }, - { 5301, 159, 280, 276, JoinPartyCallback_t_w_from_u }, - { 5302, 159, 16, 12, CreateBeaconCallback_t_w_from_u }, + { 4523, 160, 16, 12, HTML_StatusText_t_w_from_u }, + { 4524, 160, 16, 12, HTML_ShowToolTip_t_w_from_u }, + { 4525, 160, 16, 12, HTML_UpdateToolTip_t_w_from_u }, + { 4704, 160, 24, 20, SteamInventoryStartPurchaseResult_t_w_from_u }, + { 5211, 160, 16, 12, RequestPlayersForGameProgressCallback_t_w_from_u }, + { 5212, 160, 64, 56, RequestPlayersForGameResultCallback_t_w_from_u }, + { 5213, 160, 24, 20, RequestPlayersForGameFinalResultCallback_t_w_from_u }, + { 5214, 160, 24, 20, SubmitPlayerResultResultCallback_t_w_from_u }, + { 5215, 160, 16, 12, EndGameResultCallback_t_w_from_u }, + { 5301, 160, 280, 276, JoinPartyCallback_t_w_from_u }, + { 5302, 160, 16, 12, CreateBeaconCallback_t_w_from_u }, }; #endif const unsigned int callback_data_size = ARRAY_SIZE(callback_data); diff --git a/lsteamclient/unixlib_generated.h b/lsteamclient/unixlib_generated.h index 7e5f322893..bc8d7de14f 100644 --- a/lsteamclient/unixlib_generated.h +++ b/lsteamclient/unixlib_generated.h @@ -904,6 +904,34 @@ struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext_params uint32_t nAppID; }; +struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas_params +{ + struct u_steam_iface *linux_side; + int32_t _ret; + int32_t *pnAvailable; + int32_t *pnPrivate; +}; + +struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + int32_t iBetaIndex; + uint32_t *punFlags; + uint32_t *punBuildID; + char *pchBetaName; + int32_t cchBetaName; + char *pchDescription; + int32_t cchDescription; +}; + +struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + const char *pchBetaName; +}; + struct ISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001_GetAppOwnershipTicketData_params { struct u_steam_iface *linux_side; @@ -17764,6 +17792,799 @@ struct ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetUserContentDescriptorPreferenc uint32_t cMaxEntries; }; +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t unAccountID; + uint32_t eListType; + uint32_t eMatchingUGCType; + uint32_t eSortOrder; + uint32_t nCreatorAppID; + uint32_t nConsumerAppID; + uint32_t unPage; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t eQueryType; + uint32_t eMatchingeMatchingUGCTypeFileType; + uint32_t nCreatorAppID; + uint32_t nConsumerAppID; + uint32_t unPage; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t eQueryType; + uint32_t eMatchingeMatchingUGCTypeFileType; + uint32_t nCreatorAppID; + uint32_t nConsumerAppID; + const char *pchCursor; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t *pvecPublishedFileID; + uint32_t unNumPublishedFileIDs; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t handle; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + w_SteamUGCDetails_t_160 *pDetails; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint32_t index; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t indexTag; + char *pchValue; + uint32_t cchValueSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t indexTag; + char *pchValue; + uint32_t cchValueSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + char *pchURL; + uint32_t cchURLSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + char *pchMetadata; + uint32_t cchMetadatasize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint64_t *pvecPublishedFileID; + uint32_t cMaxEntries; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t eStatType; + uint64_t *pStatValue; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint32_t index; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t previewIndex; + char *pchURLOrVideoID; + uint32_t cchURLSize; + char *pchOriginalFileName; + uint32_t cchOriginalFileNameSize; + uint32_t *pPreviewType; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint32_t index; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t keyValueTagIndex; + char *pchKey; + uint32_t cchKeySize; + char *pchValue; + uint32_t cchValueSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + const char *pchKey; + char *pchValue; + uint32_t cchValueSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint32_t index; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + uint32_t versionIndex; + char *pchGameBranchMin; + char *pchGameBranchMax; + uint32_t cchGameBranchSize; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint32_t index; + uint32_t *pvecDescriptors; + uint32_t cMaxEntries; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pTagName; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const w_SteamParamStringArray_t *pTagGroups; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pTagName; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnOnlyIDs; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnKeyValueTags; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnLongDescription; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnMetadata; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnChildren; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnAdditionalPreviews; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bReturnTotalOnly; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t unDays; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchLanguage; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t unMaxAgeSeconds; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bAdminQuery; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pMatchCloudFileName; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bMatchAnyTag; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pSearchText; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t unDays; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t rtStart; + uint32_t rtEnd; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t rtStart; + uint32_t rtEnd; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pKey; + const char *pValue; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; + uint32_t unMaxAgeSeconds; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t nConsumerAppId; + uint32_t eFileType; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t nConsumerAppId; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchTitle; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchDescription; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchLanguage; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchMetaData; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t eVisibility; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t updateHandle; + const w_SteamParamStringArray_t *pTags; + int8_t bAllowAdminTags; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pszContentFolder; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pszPreviewFile; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + int8_t bAllowLegacyUpload; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchKey; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pchKey; + const char *pchValue; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pszPreviewFile; + uint32_t type; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pszVideoID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + const char *pszPreviewFile; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; + const char *pszVideoID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t index; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t descid; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + uint32_t descid; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t handle; + const char *pszGameBranchMin; + const char *pszGameBranchMax; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t handle; + const char *pchChangeNote; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t handle; + uint64_t *punBytesProcessed; + uint64_t *punBytesTotal; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; + int8_t bVoteUp; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t nAppId; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint32_t nAppId; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t *pvecPublishedFileID; + uint32_t cMaxEntries; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t nPublishedFileID; + uint64_t *punSizeOnDisk; + char *pchFolder; + uint32_t cchFolderSize; + uint32_t *punTimeStamp; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t nPublishedFileID; + uint64_t *punBytesDownloaded; + uint64_t *punBytesTotal; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint64_t nPublishedFileID; + int8_t bHighPriority; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint32_t unWorkshopDepotID; + const char *pszFolder; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads_params +{ + struct u_steam_iface *linux_side; + int8_t bSuspend; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t *pvecPublishedFileID; + uint32_t unNumPublishedFileIDs; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t *pvecPublishedFileID; + uint32_t unNumPublishedFileIDs; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nParentPublishedFileID; + uint64_t nChildPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nParentPublishedFileID; + uint64_t nChildPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; + uint32_t nAppID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; + uint32_t nAppID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; + uint64_t nPublishedFileID; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus_params +{ + struct u_steam_iface *linux_side; + uint64_t _ret; +}; + +struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences_params +{ + struct u_steam_iface *linux_side; + uint32_t _ret; + uint32_t *pvecDescriptors; + uint32_t cMaxEntries; +}; + struct ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_SendMethod_params { struct u_steam_iface *linux_side; @@ -20643,6 +21464,34 @@ struct ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFStringForApp_params int32_t *pnBufferSize; }; +struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL_params +{ + struct u_steam_iface *linux_side; + uint32_t unVideoAppID; +}; + +struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + int32_t *pnNumViewers; +}; + +struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings_params +{ + struct u_steam_iface *linux_side; + uint32_t unVideoAppID; +}; + +struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp_params +{ + struct u_steam_iface *linux_side; + int8_t _ret; + uint32_t unVideoAppID; + char *pchBuffer; + int32_t *pnBufferSize; +}; + struct ISteamClient_SteamClient006_CreateSteamPipe_params { struct u_steam_iface *linux_side; @@ -46036,6 +46885,9 @@ enum unix_funcs unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribedFromFamilySharing, unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsTimedTrial, unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext, + unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas, + unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo, + unix_ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta, unix_ISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001_GetAppOwnershipTicketData, unix_ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Init, unix_ISteamController_STEAMCONTROLLER_INTERFACE_VERSION_Shutdown, @@ -48123,6 +48975,100 @@ enum unix_funcs unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION018_ShowWorkshopEULA, unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetWorkshopEULAStatus, unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION018_GetUserContentDescriptorPreferences, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus, + unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences, unix_ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_SendMethod, unix_ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseInfo, unix_ISteamUnifiedMessages_STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001_GetMethodResponseData, @@ -48481,6 +49427,10 @@ enum unix_funcs unix_ISteamVideo_STEAMVIDEO_INTERFACE_V002_IsBroadcasting, unix_ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFSettings, unix_ISteamVideo_STEAMVIDEO_INTERFACE_V002_GetOPFStringForApp, + unix_ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL, + unix_ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting, + unix_ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings, + unix_ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp, unix_ISteamClient_SteamClient006_CreateSteamPipe, unix_ISteamClient_SteamClient006_BReleaseSteamPipe, unix_ISteamClient_SteamClient006_CreateGlobalUser, diff --git a/lsteamclient/winISteamApps.c b/lsteamclient/winISteamApps.c index 5b5905486a..81417d42a8 100644 --- a/lsteamclient/winISteamApps.c +++ b/lsteamclient/winISteamApps.c @@ -1492,6 +1492,9 @@ DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetLaunchCo DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribedFromFamilySharing, 4) DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsTimedTrial, 12) DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext, 8) +DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas, 12) +DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo, 32) +DEFINE_THISCALL_WRAPPER(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta, 8) int8_t __thiscall winISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribed(struct w_steam_iface *_this) { @@ -1853,6 +1856,50 @@ int8_t __thiscall winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext(str return params._ret; } +int32_t __thiscall winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas(struct w_steam_iface *_this, int32_t *pnAvailable, int32_t *pnPrivate) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas_params params = + { + .linux_side = _this->u_iface, + .pnAvailable = pnAvailable, + .pnPrivate = pnPrivate, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo(struct w_steam_iface *_this, int32_t iBetaIndex, uint32_t *punFlags, uint32_t *punBuildID, char *pchBetaName, int32_t cchBetaName, char *pchDescription, int32_t cchDescription) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo_params params = + { + .linux_side = _this->u_iface, + .iBetaIndex = iBetaIndex, + .punFlags = punFlags, + .punBuildID = punBuildID, + .pchBetaName = pchBetaName, + .cchBetaName = cchBetaName, + .pchDescription = pchDescription, + .cchDescription = cchDescription, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta(struct w_steam_iface *_this, const char *pchBetaName) +{ + struct ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta_params params = + { + .linux_side = _this->u_iface, + .pchBetaName = pchBetaName, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchBetaName, -1); + STEAMCLIENT_CALL( ISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta, ¶ms ); + return params._ret; +} + extern vtable_ptr winISteamApps_STEAMAPPS_INTERFACE_VERSION008_vtable; DEFINE_RTTI_DATA0(winISteamApps_STEAMAPPS_INTERFACE_VERSION008, 0, ".?AVISteamApps@@") @@ -1889,6 +1936,9 @@ __ASM_BLOCK_BEGIN(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_vtables) VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribedFromFamilySharing) VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsTimedTrial) VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetDlcContext) + VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetNumBetas) + VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_GetBetaInfo) + VTABLE_ADD_FUNC(winISteamApps_STEAMAPPS_INTERFACE_VERSION008_SetActiveBeta) ); __ASM_BLOCK_END @@ -1896,7 +1946,7 @@ struct w_steam_iface *create_winISteamApps_STEAMAPPS_INTERFACE_VERSION008(void * { struct w_steam_iface *r = alloc_mem_for_iface(sizeof(struct w_steam_iface), "STEAMAPPS_INTERFACE_VERSION008"); TRACE("-> %p\n", r); - r->vtable = alloc_vtable(&winISteamApps_STEAMAPPS_INTERFACE_VERSION008_vtable, 30, "STEAMAPPS_INTERFACE_VERSION008"); + r->vtable = alloc_vtable(&winISteamApps_STEAMAPPS_INTERFACE_VERSION008_vtable, 33, "STEAMAPPS_INTERFACE_VERSION008"); r->u_iface = u_iface; return r; } diff --git a/lsteamclient/winISteamUGC.c b/lsteamclient/winISteamUGC.c index 546569e20f..daae012e31 100644 --- a/lsteamclient/winISteamUGC.c +++ b/lsteamclient/winISteamUGC.c @@ -16755,6 +16755,1502 @@ struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION018(void *u_ return r; } +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest, 32) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag, 28) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName, 28) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview, 40) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag, 36) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2, 28) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData, 32) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors, 24) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems, 4) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo, 28) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads, 8) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems, 4) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency, 20) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency, 16) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem, 12) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA, 4) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus, 4) +DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences, 12) + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest(struct w_steam_iface *_this, uint32_t unAccountID, uint32_t eListType, uint32_t eMatchingUGCType, uint32_t eSortOrder, uint32_t nCreatorAppID, uint32_t nConsumerAppID, uint32_t unPage) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest_params params = + { + .linux_side = _this->u_iface, + .unAccountID = unAccountID, + .eListType = eListType, + .eMatchingUGCType = eMatchingUGCType, + .eSortOrder = eSortOrder, + .nCreatorAppID = nCreatorAppID, + .nConsumerAppID = nConsumerAppID, + .unPage = unPage, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest(struct w_steam_iface *_this, uint32_t eQueryType, uint32_t eMatchingeMatchingUGCTypeFileType, uint32_t nCreatorAppID, uint32_t nConsumerAppID, uint32_t unPage) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_params params = + { + .linux_side = _this->u_iface, + .eQueryType = eQueryType, + .eMatchingeMatchingUGCTypeFileType = eMatchingeMatchingUGCTypeFileType, + .nCreatorAppID = nCreatorAppID, + .nConsumerAppID = nConsumerAppID, + .unPage = unPage, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2(struct w_steam_iface *_this, uint32_t eQueryType, uint32_t eMatchingeMatchingUGCTypeFileType, uint32_t nCreatorAppID, uint32_t nConsumerAppID, const char *pchCursor) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2_params params = + { + .linux_side = _this->u_iface, + .eQueryType = eQueryType, + .eMatchingeMatchingUGCTypeFileType = eMatchingeMatchingUGCTypeFileType, + .nCreatorAppID = nCreatorAppID, + .nConsumerAppID = nConsumerAppID, + .pchCursor = pchCursor, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchCursor, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest(struct w_steam_iface *_this, uint64_t *pvecPublishedFileID, uint32_t unNumPublishedFileIDs) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest_params params = + { + .linux_side = _this->u_iface, + .pvecPublishedFileID = pvecPublishedFileID, + .unNumPublishedFileIDs = unNumPublishedFileIDs, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest(struct w_steam_iface *_this, uint64_t handle) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult(struct w_steam_iface *_this, uint64_t handle, uint32_t index, w_SteamUGCDetails_t_160 *pDetails) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pDetails = pDetails, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags(struct w_steam_iface *_this, uint64_t handle, uint32_t index) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t indexTag, char *pchValue, uint32_t cchValueSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .indexTag = indexTag, + .pchValue = pchValue, + .cchValueSize = cchValueSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t indexTag, char *pchValue, uint32_t cchValueSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .indexTag = indexTag, + .pchValue = pchValue, + .cchValueSize = cchValueSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL(struct w_steam_iface *_this, uint64_t handle, uint32_t index, char *pchURL, uint32_t cchURLSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pchURL = pchURL, + .cchURLSize = cchURLSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata(struct w_steam_iface *_this, uint64_t handle, uint32_t index, char *pchMetadata, uint32_t cchMetadatasize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pchMetadata = pchMetadata, + .cchMetadatasize = cchMetadatasize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint64_t *pvecPublishedFileID, uint32_t cMaxEntries) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pvecPublishedFileID = pvecPublishedFileID, + .cMaxEntries = cMaxEntries, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t eStatType, uint64_t *pStatValue) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .eStatType = eStatType, + .pStatValue = pStatValue, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews(struct w_steam_iface *_this, uint64_t handle, uint32_t index) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t previewIndex, char *pchURLOrVideoID, uint32_t cchURLSize, char *pchOriginalFileName, uint32_t cchOriginalFileNameSize, uint32_t *pPreviewType) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .previewIndex = previewIndex, + .pchURLOrVideoID = pchURLOrVideoID, + .cchURLSize = cchURLSize, + .pchOriginalFileName = pchOriginalFileName, + .cchOriginalFileNameSize = cchOriginalFileNameSize, + .pPreviewType = pPreviewType, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags(struct w_steam_iface *_this, uint64_t handle, uint32_t index) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t keyValueTagIndex, char *pchKey, uint32_t cchKeySize, char *pchValue, uint32_t cchValueSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .keyValueTagIndex = keyValueTagIndex, + .pchKey = pchKey, + .cchKeySize = cchKeySize, + .pchValue = pchValue, + .cchValueSize = cchValueSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2(struct w_steam_iface *_this, uint64_t handle, uint32_t index, const char *pchKey, char *pchValue, uint32_t cchValueSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pchKey = pchKey, + .pchValue = pchValue, + .cchValueSize = cchValueSize, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchKey, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions(struct w_steam_iface *_this, uint64_t handle, uint32_t index) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t versionIndex, char *pchGameBranchMin, char *pchGameBranchMax, uint32_t cchGameBranchSize) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .versionIndex = versionIndex, + .pchGameBranchMin = pchGameBranchMin, + .pchGameBranchMax = pchGameBranchMax, + .cchGameBranchSize = cchGameBranchSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors(struct w_steam_iface *_this, uint64_t handle, uint32_t index, uint32_t *pvecDescriptors, uint32_t cMaxEntries) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pvecDescriptors = pvecDescriptors, + .cMaxEntries = cMaxEntries, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest(struct w_steam_iface *_this, uint64_t handle) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag(struct w_steam_iface *_this, uint64_t handle, const char *pTagName) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pTagName = pTagName, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pTagName, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup(struct w_steam_iface *_this, uint64_t handle, const w_SteamParamStringArray_t *pTagGroups) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pTagGroups = pTagGroups, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag(struct w_steam_iface *_this, uint64_t handle, const char *pTagName) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pTagName = pTagName, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pTagName, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnOnlyIDs) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnOnlyIDs = bReturnOnlyIDs, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnKeyValueTags) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnKeyValueTags = bReturnKeyValueTags, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnLongDescription) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnLongDescription = bReturnLongDescription, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnMetadata) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnMetadata = bReturnMetadata, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnChildren) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnChildren = bReturnChildren, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnAdditionalPreviews) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnAdditionalPreviews = bReturnAdditionalPreviews, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly(struct w_steam_iface *_this, uint64_t handle, int8_t bReturnTotalOnly) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bReturnTotalOnly = bReturnTotalOnly, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats(struct w_steam_iface *_this, uint64_t handle, uint32_t unDays) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .unDays = unDays, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage(struct w_steam_iface *_this, uint64_t handle, const char *pchLanguage) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchLanguage = pchLanguage, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchLanguage, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse(struct w_steam_iface *_this, uint64_t handle, uint32_t unMaxAgeSeconds) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .unMaxAgeSeconds = unMaxAgeSeconds, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery(struct w_steam_iface *_this, uint64_t handle, int8_t bAdminQuery) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bAdminQuery = bAdminQuery, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter(struct w_steam_iface *_this, uint64_t handle, const char *pMatchCloudFileName) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pMatchCloudFileName = pMatchCloudFileName, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pMatchCloudFileName, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag(struct w_steam_iface *_this, uint64_t handle, int8_t bMatchAnyTag) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bMatchAnyTag = bMatchAnyTag, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText(struct w_steam_iface *_this, uint64_t handle, const char *pSearchText) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pSearchText = pSearchText, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pSearchText, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays(struct w_steam_iface *_this, uint64_t handle, uint32_t unDays) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .unDays = unDays, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange(struct w_steam_iface *_this, uint64_t handle, uint32_t rtStart, uint32_t rtEnd) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .rtStart = rtStart, + .rtEnd = rtEnd, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange(struct w_steam_iface *_this, uint64_t handle, uint32_t rtStart, uint32_t rtEnd) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .rtStart = rtStart, + .rtEnd = rtEnd, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag(struct w_steam_iface *_this, uint64_t handle, const char *pKey, const char *pValue) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pKey = pKey, + .pValue = pValue, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pKey, -1); + IsBadStringPtrA(pValue, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails(struct w_steam_iface *_this, uint64_t nPublishedFileID, uint32_t unMaxAgeSeconds) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .unMaxAgeSeconds = unMaxAgeSeconds, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem(struct w_steam_iface *_this, uint32_t nConsumerAppId, uint32_t eFileType) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem_params params = + { + .linux_side = _this->u_iface, + .nConsumerAppId = nConsumerAppId, + .eFileType = eFileType, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate(struct w_steam_iface *_this, uint32_t nConsumerAppId, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate_params params = + { + .linux_side = _this->u_iface, + .nConsumerAppId = nConsumerAppId, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle(struct w_steam_iface *_this, uint64_t handle, const char *pchTitle) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchTitle = pchTitle, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchTitle, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription(struct w_steam_iface *_this, uint64_t handle, const char *pchDescription) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchDescription = pchDescription, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchDescription, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage(struct w_steam_iface *_this, uint64_t handle, const char *pchLanguage) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchLanguage = pchLanguage, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchLanguage, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata(struct w_steam_iface *_this, uint64_t handle, const char *pchMetaData) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchMetaData = pchMetaData, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchMetaData, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility(struct w_steam_iface *_this, uint64_t handle, uint32_t eVisibility) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .eVisibility = eVisibility, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags(struct w_steam_iface *_this, uint64_t updateHandle, const w_SteamParamStringArray_t *pTags, int8_t bAllowAdminTags) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags_params params = + { + .linux_side = _this->u_iface, + .updateHandle = updateHandle, + .pTags = pTags, + .bAllowAdminTags = bAllowAdminTags, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent(struct w_steam_iface *_this, uint64_t handle, const char *pszContentFolder) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pszContentFolder = pszContentFolder, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszContentFolder, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview(struct w_steam_iface *_this, uint64_t handle, const char *pszPreviewFile) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pszPreviewFile = pszPreviewFile, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszPreviewFile, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload(struct w_steam_iface *_this, uint64_t handle, int8_t bAllowLegacyUpload) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .bAllowLegacyUpload = bAllowLegacyUpload, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags(struct w_steam_iface *_this, uint64_t handle) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags(struct w_steam_iface *_this, uint64_t handle, const char *pchKey) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchKey = pchKey, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchKey, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag(struct w_steam_iface *_this, uint64_t handle, const char *pchKey, const char *pchValue) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchKey = pchKey, + .pchValue = pchValue, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchKey, -1); + IsBadStringPtrA(pchValue, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile(struct w_steam_iface *_this, uint64_t handle, const char *pszPreviewFile, uint32_t type) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pszPreviewFile = pszPreviewFile, + .type = type, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszPreviewFile, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo(struct w_steam_iface *_this, uint64_t handle, const char *pszVideoID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pszVideoID = pszVideoID, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszVideoID, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile(struct w_steam_iface *_this, uint64_t handle, uint32_t index, const char *pszPreviewFile) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pszPreviewFile = pszPreviewFile, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszPreviewFile, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo(struct w_steam_iface *_this, uint64_t handle, uint32_t index, const char *pszVideoID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + .pszVideoID = pszVideoID, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszVideoID, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview(struct w_steam_iface *_this, uint64_t handle, uint32_t index) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .index = index, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor(struct w_steam_iface *_this, uint64_t handle, uint32_t descid) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .descid = descid, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor(struct w_steam_iface *_this, uint64_t handle, uint32_t descid) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .descid = descid, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions(struct w_steam_iface *_this, uint64_t handle, const char *pszGameBranchMin, const char *pszGameBranchMax) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pszGameBranchMin = pszGameBranchMin, + .pszGameBranchMax = pszGameBranchMax, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszGameBranchMin, -1); + IsBadStringPtrA(pszGameBranchMax, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate(struct w_steam_iface *_this, uint64_t handle, const char *pchChangeNote) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .pchChangeNote = pchChangeNote, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchChangeNote, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress(struct w_steam_iface *_this, uint64_t handle, uint64_t *punBytesProcessed, uint64_t *punBytesTotal) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress_params params = + { + .linux_side = _this->u_iface, + .handle = handle, + .punBytesProcessed = punBytesProcessed, + .punBytesTotal = punBytesTotal, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote(struct w_steam_iface *_this, uint64_t nPublishedFileID, int8_t bVoteUp) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .bVoteUp = bVoteUp, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites(struct w_steam_iface *_this, uint32_t nAppId, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites_params params = + { + .linux_side = _this->u_iface, + .nAppId = nAppId, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites(struct w_steam_iface *_this, uint32_t nAppId, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites_params params = + { + .linux_side = _this->u_iface, + .nAppId = nAppId, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems(struct w_steam_iface *_this) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems_params params = + { + .linux_side = _this->u_iface, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems(struct w_steam_iface *_this, uint64_t *pvecPublishedFileID, uint32_t cMaxEntries) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems_params params = + { + .linux_side = _this->u_iface, + .pvecPublishedFileID = pvecPublishedFileID, + .cMaxEntries = cMaxEntries, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo(struct w_steam_iface *_this, uint64_t nPublishedFileID, uint64_t *punSizeOnDisk, char *pchFolder, uint32_t cchFolderSize, uint32_t *punTimeStamp) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .punSizeOnDisk = punSizeOnDisk, + .pchFolder = pchFolder, + .cchFolderSize = cchFolderSize, + .punTimeStamp = punTimeStamp, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo(struct w_steam_iface *_this, uint64_t nPublishedFileID, uint64_t *punBytesDownloaded, uint64_t *punBytesTotal) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .punBytesDownloaded = punBytesDownloaded, + .punBytesTotal = punBytesTotal, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem(struct w_steam_iface *_this, uint64_t nPublishedFileID, int8_t bHighPriority) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .bHighPriority = bHighPriority, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer(struct w_steam_iface *_this, uint32_t unWorkshopDepotID, const char *pszFolder) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer_params params = + { + .linux_side = _this->u_iface, + .unWorkshopDepotID = unWorkshopDepotID, + .pszFolder = pszFolder, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pszFolder, -1); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer, ¶ms ); + return params._ret; +} + +void __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads(struct w_steam_iface *_this, int8_t bSuspend) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads_params params = + { + .linux_side = _this->u_iface, + .bSuspend = bSuspend, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads, ¶ms ); +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking(struct w_steam_iface *_this, uint64_t *pvecPublishedFileID, uint32_t unNumPublishedFileIDs) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking_params params = + { + .linux_side = _this->u_iface, + .pvecPublishedFileID = pvecPublishedFileID, + .unNumPublishedFileIDs = unNumPublishedFileIDs, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking(struct w_steam_iface *_this, uint64_t *pvecPublishedFileID, uint32_t unNumPublishedFileIDs) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking_params params = + { + .linux_side = _this->u_iface, + .pvecPublishedFileID = pvecPublishedFileID, + .unNumPublishedFileIDs = unNumPublishedFileIDs, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems(struct w_steam_iface *_this) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems_params params = + { + .linux_side = _this->u_iface, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency(struct w_steam_iface *_this, uint64_t nParentPublishedFileID, uint64_t nChildPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency_params params = + { + .linux_side = _this->u_iface, + .nParentPublishedFileID = nParentPublishedFileID, + .nChildPublishedFileID = nChildPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency(struct w_steam_iface *_this, uint64_t nParentPublishedFileID, uint64_t nChildPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency_params params = + { + .linux_side = _this->u_iface, + .nParentPublishedFileID = nParentPublishedFileID, + .nChildPublishedFileID = nChildPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency(struct w_steam_iface *_this, uint64_t nPublishedFileID, uint32_t nAppID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .nAppID = nAppID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency(struct w_steam_iface *_this, uint64_t nPublishedFileID, uint32_t nAppID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + .nAppID = nAppID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem(struct w_steam_iface *_this, uint64_t nPublishedFileID) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem_params params = + { + .linux_side = _this->u_iface, + .nPublishedFileID = nPublishedFileID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem, ¶ms ); + return params._ret; +} + +int8_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA(struct w_steam_iface *_this) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA_params params = + { + .linux_side = _this->u_iface, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA, ¶ms ); + return params._ret; +} + +uint64_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus(struct w_steam_iface *_this) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus_params params = + { + .linux_side = _this->u_iface, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus, ¶ms ); + return params._ret; +} + +uint32_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences(struct w_steam_iface *_this, uint32_t *pvecDescriptors, uint32_t cMaxEntries) +{ + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences_params params = + { + .linux_side = _this->u_iface, + .pvecDescriptors = pvecDescriptors, + .cMaxEntries = cMaxEntries, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences, ¶ms ); + return params._ret; +} + +extern vtable_ptr winISteamUGC_STEAMUGC_INTERFACE_VERSION020_vtable; + +DEFINE_RTTI_DATA0(winISteamUGC_STEAMUGC_INTERFACE_VERSION020, 0, ".?AVISteamUGC@@") + +__ASM_BLOCK_BEGIN(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_vtables) + __ASM_VTABLE(winISteamUGC_STEAMUGC_INTERFACE_VERSION020, + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUserUGCRequest) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest_2) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryAllUGCRequest) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateQueryUGCDetailsRequest) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SendQueryUGCRequest) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCResult) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCTagDisplayName) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCPreviewURL) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCMetadata) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCChildren) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCStatistic) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumAdditionalPreviews) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCAdditionalPreview) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCNumKeyValueTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag_2) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCKeyValueTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSupportedGameVersions) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSupportedGameVersionData) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetQueryUGCContentDescriptors) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ReleaseQueryUGCRequest) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredTagGroup) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddExcludedTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnOnlyIDs) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnKeyValueTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnLongDescription) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnMetadata) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnChildren) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnAdditionalPreviews) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnTotalOnly) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetReturnPlaytimeStats) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetLanguage) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowCachedResponse) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAdminQuery) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetCloudFileNameFilter) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetMatchAnyTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetSearchText) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRankedByTrendDays) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeCreatedDateRange) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetTimeUpdatedDateRange) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddRequiredKeyValueTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RequestUGCDetails) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_CreateItem) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartItemUpdate) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTitle) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemDescription) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemUpdateLanguage) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemMetadata) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemVisibility) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemContent) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetItemPreview) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetAllowLegacyUpload) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAllItemKeyValueTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemKeyValueTags) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemKeyValueTag) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewFile) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemPreviewVideo) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewFile) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UpdateItemPreviewVideo) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemPreview) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddContentDescriptor) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveContentDescriptor) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetRequiredGameVersions) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubmitItemUpdate) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemUpdateProgress) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SetUserItemVote) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserItemVote) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddItemToFavorites) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveItemFromFavorites) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SubscribeItem) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_UnsubscribeItem) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetNumSubscribedItems) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetSubscribedItems) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemState) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemInstallInfo) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetItemDownloadInfo) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DownloadItem) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_BInitWorkshopForGameServer) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_SuspendDownloads) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StartPlaytimeTracking) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTracking) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_StopPlaytimeTrackingForAllItems) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddDependency) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveDependency) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_AddAppDependency) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_RemoveAppDependency) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetAppDependencies) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_DeleteItem) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_ShowWorkshopEULA) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetWorkshopEULAStatus) + VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION020_GetUserContentDescriptorPreferences) + ); +__ASM_BLOCK_END + +struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION020(void *u_iface) +{ + struct w_steam_iface *r = alloc_mem_for_iface(sizeof(struct w_steam_iface), "STEAMUGC_INTERFACE_VERSION020"); + TRACE("-> %p\n", r); + r->vtable = alloc_vtable(&winISteamUGC_STEAMUGC_INTERFACE_VERSION020_vtable, 94, "STEAMUGC_INTERFACE_VERSION020"); + r->u_iface = u_iface; + return r; +} + void init_winISteamUGC_rtti( char *base ) { #ifdef __x86_64__ @@ -16775,5 +18271,6 @@ void init_winISteamUGC_rtti( char *base ) init_winISteamUGC_STEAMUGC_INTERFACE_VERSION016_rtti( base ); init_winISteamUGC_STEAMUGC_INTERFACE_VERSION017_rtti( base ); init_winISteamUGC_STEAMUGC_INTERFACE_VERSION018_rtti( base ); + init_winISteamUGC_STEAMUGC_INTERFACE_VERSION020_rtti( base ); #endif /* __x86_64__ */ } diff --git a/lsteamclient/winISteamVideo.c b/lsteamclient/winISteamVideo.c index f5b5183891..d952bff321 100644 --- a/lsteamclient/winISteamVideo.c +++ b/lsteamclient/winISteamVideo.c @@ -124,10 +124,86 @@ struct w_steam_iface *create_winISteamVideo_STEAMVIDEO_INTERFACE_V002(void *u_if return r; } +DEFINE_THISCALL_WRAPPER(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL, 8) +DEFINE_THISCALL_WRAPPER(winISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting, 8) +DEFINE_THISCALL_WRAPPER(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings, 8) +DEFINE_THISCALL_WRAPPER(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp, 16) + +void __thiscall winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL(struct w_steam_iface *_this, uint32_t unVideoAppID) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL_params params = + { + .linux_side = _this->u_iface, + .unVideoAppID = unVideoAppID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL, ¶ms ); +} + +int8_t __thiscall winISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting(struct w_steam_iface *_this, int32_t *pnNumViewers) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting_params params = + { + .linux_side = _this->u_iface, + .pnNumViewers = pnNumViewers, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting, ¶ms ); + return params._ret; +} + +void __thiscall winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings(struct w_steam_iface *_this, uint32_t unVideoAppID) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings_params params = + { + .linux_side = _this->u_iface, + .unVideoAppID = unVideoAppID, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings, ¶ms ); +} + +int8_t __thiscall winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp(struct w_steam_iface *_this, uint32_t unVideoAppID, char *pchBuffer, int32_t *pnBufferSize) +{ + struct ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp_params params = + { + .linux_side = _this->u_iface, + .unVideoAppID = unVideoAppID, + .pchBuffer = pchBuffer, + .pnBufferSize = pnBufferSize, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp, ¶ms ); + return params._ret; +} + +extern vtable_ptr winISteamVideo_STEAMVIDEO_INTERFACE_V007_vtable; + +DEFINE_RTTI_DATA0(winISteamVideo_STEAMVIDEO_INTERFACE_V007, 0, ".?AVISteamVideo@@") + +__ASM_BLOCK_BEGIN(winISteamVideo_STEAMVIDEO_INTERFACE_V007_vtables) + __ASM_VTABLE(winISteamVideo_STEAMVIDEO_INTERFACE_V007, + VTABLE_ADD_FUNC(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetVideoURL) + VTABLE_ADD_FUNC(winISteamVideo_STEAMVIDEO_INTERFACE_V007_IsBroadcasting) + VTABLE_ADD_FUNC(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFSettings) + VTABLE_ADD_FUNC(winISteamVideo_STEAMVIDEO_INTERFACE_V007_GetOPFStringForApp) + ); +__ASM_BLOCK_END + +struct w_steam_iface *create_winISteamVideo_STEAMVIDEO_INTERFACE_V007(void *u_iface) +{ + struct w_steam_iface *r = alloc_mem_for_iface(sizeof(struct w_steam_iface), "STEAMVIDEO_INTERFACE_V007"); + TRACE("-> %p\n", r); + r->vtable = alloc_vtable(&winISteamVideo_STEAMVIDEO_INTERFACE_V007_vtable, 4, "STEAMVIDEO_INTERFACE_V007"); + r->u_iface = u_iface; + return r; +} + void init_winISteamVideo_rtti( char *base ) { #ifdef __x86_64__ init_winISteamVideo_STEAMVIDEO_INTERFACE_V001_rtti( base ); init_winISteamVideo_STEAMVIDEO_INTERFACE_V002_rtti( base ); + init_winISteamVideo_STEAMVIDEO_INTERFACE_V007_rtti( base ); #endif /* __x86_64__ */ } From ba0cf51aa914b6a973da66517d47bd8ed0c56bcb Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Thu, 27 Jun 2024 21:19:39 -0500 Subject: [PATCH 033/141] proton: Enable Xalia on MultiVersus CW-Bug-Id: #23876 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 345b17cca0..9445066724 100755 --- a/proton +++ b/proton @@ -1157,6 +1157,7 @@ def default_compat_config(): "397950", # Clustertruck "489830", # The Elder Scrolls V: Skyrim Special Edition "712180", # Mugsters + "1818750", # MultiVersus ]: ret.add("xalia") From 903eae805fa78d35c8f7345a90657fbaea2c17d6 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Fri, 28 Jun 2024 13:27:09 -0600 Subject: [PATCH 034/141] proton: Add Farlight 84 to MFDXGI hack. CW-Bug-Id: #23986 --- proton | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proton b/proton index 9445066724..9c995484a2 100755 --- a/proton +++ b/proton @@ -1027,6 +1027,8 @@ def default_compat_config(): "1522260", #Iragon: Prologue 18+ "2229300", #Iragon "1097480", #Iragon 18+ + #CW bug 23986 + "1928420", ]: ret.add("nomfdxgiman") From f0742708cd244a9e1b42659b0aea4d2e6cf252ed Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Mon, 1 Jul 2024 19:58:12 +0000 Subject: [PATCH 035/141] Update Wine Mono to 9.2.0. --- Makefile.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index f04d41362f..5fc0f6f1dc 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1035,7 +1035,7 @@ all-dist: $(DIST_GECKO32) $(DIST_GECKO64) ## wine-mono ## -WINEMONO_VER := 9.1.0 +WINEMONO_VER := 9.2.0 WINEMONO_TARBALL := wine-mono-$(WINEMONO_VER)-x86.tar.xz DIST_WINEMONO_DIR := $(DST_DIR)/share/wine/mono DIST_WINEMONO := $(OBJ)/.wine-mono-dist From 4f856cc376b22ca461650b63f2754b82033b112b Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 2 Jul 2024 17:35:30 -0600 Subject: [PATCH 036/141] build: Build apetag gstreamer plugin. CW-Bug-Id: #23991 --- Makefile.in | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile.in b/Makefile.in index 5fc0f6f1dc..19cdab83ea 100644 --- a/Makefile.in +++ b/Makefile.in @@ -188,6 +188,7 @@ $(eval $(call rules-meson,gst_base,64)) ## GST_GOOD_MESON_ARGS := \ + -Dapetag=enabled \ -Dauto_features=disabled \ -Daudioparsers=enabled \ -Dautodetect=enabled \ From 354682eee80a7133671f387347d6ba328415d825 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Mon, 8 Jul 2024 20:38:40 +0300 Subject: [PATCH 037/141] proton: Disable nvapi for Battle Brothers. --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 9c995484a2..2a28740bc9 100755 --- a/proton +++ b/proton @@ -1134,6 +1134,7 @@ def default_compat_config(): "109600", #Neverwinter "9900", #Star Trek Online "9880", #Champions Online + "365360", #Battle Brothers ]: ret.add("disablenvapi") From 72a8208ff17e889edec70545d750460ab19dbf70 Mon Sep 17 00:00:00 2001 From: Zhiyi Zhang Date: Tue, 9 Jul 2024 11:12:42 +0800 Subject: [PATCH 038/141] Revert "proton: Added Iragon and Iragon 18+ to MFDXGI hack" This reverts commit 436634421b0955c8b520d82ee1b1be6f8fadb594. The hack is no longer needed and causes the game to crash after a game update. CW-Bug-Id: #23184 --- proton | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/proton b/proton index 2a28740bc9..14fd5598db 100755 --- a/proton +++ b/proton @@ -1025,8 +1025,7 @@ def default_compat_config(): #affected by CW bug 23184 "2229490", #Iragon: Prologue "1522260", #Iragon: Prologue 18+ - "2229300", #Iragon - "1097480", #Iragon 18+ + #CW bug 23986 "1928420", ]: From 97f35abb16299ccc2eb9c0f33b3ee2cbef36666f Mon Sep 17 00:00:00 2001 From: Zhiyi Zhang Date: Tue, 9 Jul 2024 11:13:49 +0800 Subject: [PATCH 039/141] Revert "proton: Added Iragon: Prologue 18+ (1522260) to MFDXGI hack" This reverts commit 500d6608c401105bb251634d23ad11fb91089ef9. The hack is no longer needed and causes the game to crash after a game update. CW-Bug-Id: #23184 --- proton | 1 - 1 file changed, 1 deletion(-) diff --git a/proton b/proton index 14fd5598db..8853226a71 100755 --- a/proton +++ b/proton @@ -1024,7 +1024,6 @@ def default_compat_config(): #affected by CW bug 23184 "2229490", #Iragon: Prologue - "1522260", #Iragon: Prologue 18+ #CW bug 23986 "1928420", From 3c7deb104734b2208d4ff66e7e98ae9ac2ae045d Mon Sep 17 00:00:00 2001 From: Zhiyi Zhang Date: Tue, 9 Jul 2024 11:14:49 +0800 Subject: [PATCH 040/141] Revert "proton: Add Iragon: Prologue (2229490) to MFDXGI manager hack." This reverts commit 44c58e08574bd4a44fb3c31a58c03f9c8073a588. The hack is no longer needed and causes the game to crash after a game update. CW-Bug-Id: #23184 --- proton | 3 --- 1 file changed, 3 deletions(-) diff --git a/proton b/proton index 8853226a71..099524072f 100755 --- a/proton +++ b/proton @@ -1022,9 +1022,6 @@ def default_compat_config(): #affected by CW bug 19741 "1017900", #Age of Empires: Definitive Edition - #affected by CW bug 23184 - "2229490", #Iragon: Prologue - #CW bug 23986 "1928420", ]: From dbc6c0eaf76bcc92686b97df79a0e87728ee1860 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Tue, 9 Jul 2024 12:43:14 +0300 Subject: [PATCH 041/141] proton: Add PROTON_DXVK_D3D8 / dxvkd3d8. --- README.md | 1 + proton | 10 +++++++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index cab55b4f76..730e39995a 100644 --- a/README.md +++ b/README.md @@ -291,6 +291,7 @@ the Wine prefix. Removing the option will revert to the previous behavior. | `wined3d` | `PROTON_USE_WINED3D` | Use OpenGL-based wined3d instead of Vulkan-based DXVK for d3d11, d3d10, and d3d9. | | `nod3d11` | `PROTON_NO_D3D11` | Disable `d3d11.dll`, for d3d11 games which can fall back to and run better with d3d9. | | `nod3d10` | `PROTON_NO_D3D10` | Disable `d3d10.dll` and `dxgi.dll`, for d3d10 games which can fall back to and run better with d3d9. | +| `dxvkd3d8` | `PROTON_DXVK_D3D8` | Use DXVK's `d3d8.dll`. | | `noesync` | `PROTON_NO_ESYNC` | Do not use eventfd-based in-process synchronization primitives. | | `nofsync` | `PROTON_NO_FSYNC` | Do not use futex-based in-process synchronization primitives. (Automatically disabled on systems with no `FUTEX_WAIT_MULTIPLE` support.) | | `noxim` | `PROTON_NO_XIM` | Enabled by default. Do not attempt to use XIM (X Input Methods) support. XIM support is known to cause crashes with libx11 older than version 1.7. | diff --git a/proton b/proton index 099524072f..7d20627772 100755 --- a/proton +++ b/proton @@ -40,7 +40,7 @@ from random import randrange #To enable debug logging, copy "user_settings.sample.py" to "user_settings.py" #and edit it if needed. -CURRENT_PREFIX_VERSION="9.0-201" +CURRENT_PREFIX_VERSION="9.0-202" PFX="Proton: " ld_path_var = "LD_LIBRARY_PATH" @@ -805,6 +805,7 @@ class CompatData: use_dxvk_dxgi = not use_wined3d and \ not ("WINEDLLOVERRIDES" in g_session.env and "dxgi=b" in g_session.env["WINEDLLOVERRIDES"]) use_nvapi = 'disablenvapi' not in g_session.compat_config or 'forcenvapi' in g_session.compat_config + use_dxvk_d3d8 = "dxvkd3d8" in g_session.compat_config builtin_dll_copy = os.environ.get("PROTON_DLL_COPY", #dxsetup redist @@ -855,6 +856,7 @@ class CompatData: str(use_dxvk_dxgi), builtin_dll_copy, str(use_nvapi), + str(use_dxvk_d3d8), )) # check whether any prefix config has changed @@ -939,6 +941,11 @@ class CompatData: else: wined3dfiles.append("dxgi") + if use_dxvk_d3d8: + dxvkfiles.append("d3d8") + else: + wined3dfiles.append("d3d8") + for f in wined3dfiles: try_copy(g_proton.default_pfx_dir + "drive_c/windows/system32/" + f + ".dll", "drive_c/windows/system32", prefix=self.prefix_dir, track_file=tracked_files, link_debug=True) @@ -1350,6 +1357,7 @@ class Session: if not self.check_environment("PROTON_USE_WINED3D", "wined3d"): self.check_environment("PROTON_USE_WINED3D11", "wined3d") + self.check_environment("PROTON_DXVK_D3D8", "dxvkd3d8") self.check_environment("PROTON_NO_D3D11", "nod3d11") self.check_environment("PROTON_NO_D3D10", "nod3d10") self.check_environment("PROTON_NO_ESYNC", "noesync") From ce1e86225fa110afcdb60b2d9a82bc8d91f8a1f7 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 9 Jul 2024 10:27:53 -0600 Subject: [PATCH 042/141] proton: Enable gamedrive compat option for Aimlabs. CW-Bug-Id: #24014 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 7d20627772..78af62f683 100755 --- a/proton +++ b/proton @@ -1097,6 +1097,7 @@ def default_compat_config(): "460790", #Bayonetta "273590", #Descent 3 "834530", #Yakuza Kiwami + "714010", #Aimlabs ]: ret.add("gamedrive") From 75a1d3fd4c568a5e071587e16b54cd5dff2f4d7b Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Mon, 15 Jul 2024 10:42:15 +0300 Subject: [PATCH 043/141] proton: Disable nvapi for Alan Wake's American Nightmare. This helps with the DLC crashing. --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 78af62f683..833943707a 100755 --- a/proton +++ b/proton @@ -1138,6 +1138,7 @@ def default_compat_config(): "9900", #Star Trek Online "9880", #Champions Online "365360", #Battle Brothers + "202750", #Alan Wake's American Nightmare ]: ret.add("disablenvapi") From b036ca418ddfe8514f4747b259e7d197e6541448 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Wed, 17 Jul 2024 15:27:14 -0500 Subject: [PATCH 044/141] Revert "proton: Disable nvapi for Battle Brothers." NVAPI failure with game fixed by dxvk-nvapi update. This reverts commit 354682eee80a7133671f387347d6ba328415d825. --- proton | 1 - 1 file changed, 1 deletion(-) diff --git a/proton b/proton index 833943707a..cb82b86ed8 100755 --- a/proton +++ b/proton @@ -1137,7 +1137,6 @@ def default_compat_config(): "109600", #Neverwinter "9900", #Star Trek Online "9880", #Champions Online - "365360", #Battle Brothers "202750", #Alan Wake's American Nightmare ]: ret.add("disablenvapi") From c3a8d826bc165a4e3d7023109134eb48c748b269 Mon Sep 17 00:00:00 2001 From: Brendan McGrath Date: Thu, 18 Jul 2024 17:52:18 +1000 Subject: [PATCH 045/141] build: Add gst-plugins-bad. Enables hls, videoparsers and mpegtsdemux. CW-Bug-Id: #23810 CW-Bug-Id: #23226 CW-Bug-Id: #23425 --- Makefile.in | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index 19cdab83ea..80b49a91eb 100644 --- a/Makefile.in +++ b/Makefile.in @@ -213,6 +213,22 @@ $(eval $(call rules-source,gst_good,$(SRCDIR)/gstreamer/subprojects/gst-plugins- $(eval $(call rules-meson,gst_good,32)) $(eval $(call rules-meson,gst_good,64)) +## +## gst-plugins-bad +## + +GST_BAD_MESON_ARGS := \ + -Dauto_features=disabled \ + -Dvideoparsers=enabled \ + -Dhls=enabled \ + -Dmpegtsdemux=enabled + +GST_BAD_DEPENDS = gst_orc gstreamer gst_base + +$(eval $(call rules-source,gst_bad,$(SRCDIR)/gstreamer/subprojects/gst-plugins-bad/)) +$(eval $(call rules-meson,gst_bad,32)) +$(eval $(call rules-meson,gst_bad,64)) + ## ## FFmpeg ## @@ -1099,7 +1115,7 @@ all-dist: $(DIST_OVR32) $(DIST_OVR64) ## default_pfx ## -default_pfx: wine gst_good gst_libav gst_plugins_rs lsteamclient steamexe vrclient wineopenxr dxvk dxvk-nvapi vkd3d-proton +default_pfx: wine gst_good gst_bad gst_libav gst_plugins_rs lsteamclient steamexe vrclient wineopenxr dxvk dxvk-nvapi vkd3d-proton find $(DST_LIBDIR32)/wine -type f -execdir chmod a-w '{}' '+' find $(DST_LIBDIR64)/wine -type f -execdir chmod a-w '{}' '+' rm -rf $(abspath $(DIST_PREFIX)) From 687a81ed09284b24579bb3c54f7cf7590b863224 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20Bernon?= Date: Thu, 18 Jul 2024 18:13:31 +0200 Subject: [PATCH 046/141] update submodules --- dxvk | 2 +- dxvk-nvapi | 2 +- vkd3d-proton | 2 +- wine | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dxvk b/dxvk index 60cfafe027..bac7ae2929 160000 --- a/dxvk +++ b/dxvk @@ -1 +1 @@ -Subproject commit 60cfafe027492deab236edf80333ee3de9fa5b76 +Subproject commit bac7ae2929da476cd646507722f2e7fb51fb67d4 diff --git a/dxvk-nvapi b/dxvk-nvapi index aae4902b6f..bb3d4ad63b 160000 --- a/dxvk-nvapi +++ b/dxvk-nvapi @@ -1 +1 @@ -Subproject commit aae4902b6ff7038fd1bd34d33f019397018f195c +Subproject commit bb3d4ad63becaf9c4eebfd0a19e266d6eb8bd46e diff --git a/vkd3d-proton b/vkd3d-proton index f6d39052af..ebe7279e79 160000 --- a/vkd3d-proton +++ b/vkd3d-proton @@ -1 +1 @@ -Subproject commit f6d39052afb1fbc490b711769a0dd91c12340251 +Subproject commit ebe7279e7960d204f5b1bd3d89408929140cdd0f diff --git a/wine b/wine index f80ddae9e2..48cd14fc02 160000 --- a/wine +++ b/wine @@ -1 +1 @@ -Subproject commit f80ddae9e217f2bad68455891371fa0f524451e7 +Subproject commit 48cd14fc026c8ab87eb8ce779888b8669d7e3787 From b41d9d7a36a9acd8ba15dd6837c365b453e6baa5 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 18 Jul 2024 16:13:22 -0600 Subject: [PATCH 047/141] lsteamclient: Preserve last error in load_steamclient(). CW-Bug-Id: #24028 --- lsteamclient/steamclient_main.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lsteamclient/steamclient_main.c b/lsteamclient/steamclient_main.c index f5adbb5470..916270972c 100644 --- a/lsteamclient/steamclient_main.c +++ b/lsteamclient/steamclient_main.c @@ -342,6 +342,7 @@ static int load_steamclient(void) { char steam_app_id[4096], ignore_child_processes[4096]; struct steamclient_init_params params = {.g_tmppath = temp_path_buffer}; + DWORD saved_err = GetLastError(); if (!get_env_win(u"SteamAppId", steam_app_id, sizeof(steam_app_id))) params.steam_app_id_unset = TRUE; @@ -362,6 +363,7 @@ static int load_steamclient(void) WSAStartup(0x202, &data); wsa_initialized = TRUE; } + SetLastError(saved_err); return 1; } From 29ab2d98900edfc46db39190e5e95cc1046ee7f1 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 18 Jul 2024 17:13:21 -0600 Subject: [PATCH 048/141] lsteamclient: Reset last error in Steam_BGetCallback() on no callback return. CW-Bug-Id: #24028 --- lsteamclient/steamclient_main.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/lsteamclient/steamclient_main.c b/lsteamclient/steamclient_main.c index 916270972c..506e54e998 100644 --- a/lsteamclient/steamclient_main.c +++ b/lsteamclient/steamclient_main.c @@ -487,7 +487,11 @@ int8_t CDECL Steam_BGetCallback( int32_t pipe, w_CallbackMsg_t *win_msg, int32_t next_event: STEAMCLIENT_CALL( steamclient_Steam_BGetCallback, ¶ms ); - if (!params._ret) return FALSE; + if (!params._ret) + { + SetLastError(0); + return FALSE; + } if (!(win_msg->m_pubParam = HeapAlloc( GetProcessHeap(), 0, win_msg->m_cubParam ))) return FALSE; last_callback_data = win_msg->m_pubParam; From 548fa6434398769c20669ccf75b24e6b87cbd67a Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Fri, 19 Jul 2024 15:37:09 -0600 Subject: [PATCH 049/141] proton: Invalidate Ubisoft Launcher installation after deleting regsitry. CW-Bug-Id: #23953 --- proton | 3 +++ 1 file changed, 3 insertions(+) diff --git a/proton b/proton index cb82b86ed8..60b14c06d1 100755 --- a/proton +++ b/proton @@ -537,6 +537,9 @@ class CompatData: #proton 3.7 did not generate tracked_files, so copy it into place first try_copy(g_proton.path("proton_3.7_tracked_files"), self.tracked_files_file) self.remove_tracked_files() + path = self.prefix_dir + "/drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/version.txt" + if file_exists(path, follow_symlinks=False) and os.path.isfile(path): + os.remove(path) return if old_proton_ver == "3.7" and old_prefix_ver == "1": From e8ae65d8fae661a0896a4c73ccf3538c001731c1 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Mon, 22 Jul 2024 21:32:51 -0500 Subject: [PATCH 050/141] proton: Disable nvapi for GRID 2 and GRID Autosport CW-Bug-ID: #24055 --- proton | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proton b/proton index 60b14c06d1..dbb73b18a7 100755 --- a/proton +++ b/proton @@ -1141,6 +1141,8 @@ def default_compat_config(): "9900", #Star Trek Online "9880", #Champions Online "202750", #Alan Wake's American Nightmare + "255220", #GRID Autosport + "44350", #GRID 2 ]: ret.add("disablenvapi") From 6aeb835cb1a37749c31e56ea9266a2e6c8ea4330 Mon Sep 17 00:00:00 2001 From: Giovanni Mascellani Date: Fri, 3 May 2024 11:40:30 +0200 Subject: [PATCH 051/141] Vulkan-Loader: Remove the Vulkan loader. Its only dependency was vkd3d, but vkd3d doesn't need it. I don't know why we used to build it. --- Makefile.in | 17 +---------------- Vulkan-Loader | 1 - 2 files changed, 1 insertion(+), 17 deletions(-) delete mode 160000 Vulkan-Loader diff --git a/Makefile.in b/Makefile.in index 80b49a91eb..443e4fa976 100644 --- a/Makefile.in +++ b/Makefile.in @@ -304,21 +304,6 @@ $(eval $(call rules-cmake,spirv-headers,32,CROSS)) $(eval $(call rules-cmake,spirv-headers,64,CROSS)) -## -## Vulkan-Loader -## - -VULKAN_LOADER_CMAKE_ARGS = -DUSE_MASM=OFF -VULKAN_LOADER_CMAKE_ARGS64 = -DVULKAN_HEADERS_INSTALL_DIR=$(VULKAN_HEADERS_DST64) -VULKAN_LOADER_CMAKE_ARGS32 = -DVULKAN_HEADERS_INSTALL_DIR=$(VULKAN_HEADERS_DST32) -VULKAN_LOADER_CFLAGS = -DWINVER=0x0A00 -D_WIN32_WINNT=0x0A00 # 0x0A00 is _WIN32_WINNT_WIN10 -VULKAN_LOADER_DEPENDS = vulkan-headers spirv-headers - -$(eval $(call rules-source,vulkan-loader,$(SRCDIR)/Vulkan-Loader)) -$(eval $(call rules-cmake,vulkan-loader,32,CROSS)) -$(eval $(call rules-cmake,vulkan-loader,64,CROSS)) - - ## ## glslang ## @@ -637,7 +622,7 @@ VKD3D_CONFIGURE_ARGS = \ SONAME_LIBVULKAN=vulkan-1 \ VKD3D_LDFLAGS = -static-libgcc $(CROSSLDFLAGS) -VKD3D_DEPENDS = vulkan-loader vulkan-headers spirv-headers +VKD3D_DEPENDS = vulkan-headers spirv-headers $(eval $(call rules-source,vkd3d,$(SRCDIR)/vkd3d)) $(eval $(call rules-autoconf,vkd3d,32,CROSS)) diff --git a/Vulkan-Loader b/Vulkan-Loader deleted file mode 160000 index 538b2676ea..0000000000 --- a/Vulkan-Loader +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 538b2676eaac29565e4f1034a6f8a59ce158213d From ad8618772043e655d9b750840152383573a7abf0 Mon Sep 17 00:00:00 2001 From: Giovanni Mascellani Date: Fri, 3 May 2024 11:47:48 +0200 Subject: [PATCH 052/141] Vulkan-Headers: Update to v1.3.278. --- Vulkan-Headers | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index 8c1c27d5a9..31aa7f634b 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 8c1c27d5a9b9de8a17f500053bd08c7ca6bba19c +Subproject commit 31aa7f634b052d87ede4664053e85f3f4d1d50d3 From 9682fbb46472940222338c4221432fda30d6b952 Mon Sep 17 00:00:00 2001 From: Giovanni Mascellani Date: Fri, 3 May 2024 11:54:37 +0200 Subject: [PATCH 053/141] vkd3d: Update to vkd3d-1.12-89-g68b7f9df. --- Makefile.in | 3 +++ vkd3d | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index 443e4fa976..ae4df5e97e 100644 --- a/Makefile.in +++ b/Makefile.in @@ -621,6 +621,9 @@ VKD3D_CONFIGURE_ARGS = \ --without-ncurses \ SONAME_LIBVULKAN=vulkan-1 \ +# LTO is enabled by default, but causes the build to fail. I havent't +# investigated this yet. +VKD3D_CFLAGS = -fno-lto VKD3D_LDFLAGS = -static-libgcc $(CROSSLDFLAGS) VKD3D_DEPENDS = vulkan-headers spirv-headers diff --git a/vkd3d b/vkd3d index a16b9dffda..68b7f9df31 160000 --- a/vkd3d +++ b/vkd3d @@ -1 +1 @@ -Subproject commit a16b9dffda9becb1dbcad476c38b78f2144f35b4 +Subproject commit 68b7f9df310a27fb8e4ebac48a1452570263ac08 From 9a9f2a1cbcf381d894f44c8672bf55660764a375 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Thu, 25 Jul 2024 12:36:09 +0300 Subject: [PATCH 054/141] proton: Remove unused imports. --- proton | 3 --- 1 file changed, 3 deletions(-) diff --git a/proton b/proton index dbb73b18a7..0583fd21d0 100755 --- a/proton +++ b/proton @@ -4,9 +4,7 @@ import fcntl import array -import filecmp import fnmatch -import json import os import shutil import errno @@ -14,7 +12,6 @@ import platform import stat import subprocess import sys -import tarfile import shlex from ctypes import CDLL From f5e17b49d2b04ceb5a074805ca091b9de0bc679c Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Thu, 25 Jul 2024 12:39:20 +0300 Subject: [PATCH 055/141] proton: Chagne 'not x in y' to 'x not in y'. --- proton | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/proton b/proton index 0583fd21d0..214efcc377 100755 --- a/proton +++ b/proton @@ -53,13 +53,13 @@ def nonzero(s): return len(s) > 0 and s != "0" def prepend_to_env_str(env, variable, prepend_str, separator): - if not variable in env: + if variable not in env: env[variable] = prepend_str else: env[variable] = prepend_str + separator + env[variable] def append_to_env_str(env, variable, append_str, separator): - if not variable in env: + if variable not in env: env[variable] = append_str else: env[variable] = env[variable] + separator + append_str @@ -263,8 +263,8 @@ def getmtimestr(*path_fragments): return "0" def try_get_game_library_dir(): - if not "STEAM_COMPAT_INSTALL_PATH" in g_session.env or \ - not "STEAM_COMPAT_LIBRARY_PATHS" in g_session.env: + if "STEAM_COMPAT_INSTALL_PATH" not in g_session.env or \ + "STEAM_COMPAT_LIBRARY_PATHS" not in g_session.env: return None #find library path which is a subset of the game path @@ -276,7 +276,7 @@ def try_get_game_library_dir(): return None def try_get_steam_dir(): - if not "STEAM_COMPAT_CLIENT_INSTALL_PATH" in g_session.env: + if "STEAM_COMPAT_CLIENT_INSTALL_PATH" not in g_session.env: return None return g_session.env["STEAM_COMPAT_CLIENT_INSTALL_PATH"] @@ -514,7 +514,7 @@ class CompatData: if old_ver is None: return - if not '-' in old_ver: + if '-' not in old_ver: #How can this happen?? log("Prefix has an invalid version?! You may want to back up user files and delete this prefix.") #If it does, just let the Wine upgrade happen and hope it works... @@ -1225,7 +1225,7 @@ class Session: self.compat_config.add(cur) #turn forcelgadd on by default unless it is disabled in compat config - if not "noforcelgadd" in self.compat_config: + if "noforcelgadd" not in self.compat_config: self.compat_config.add("forcelgadd") appid = os.environ.get("SteamGameId", 0) @@ -1277,7 +1277,7 @@ class Session: prepend_to_env_str(self.env, "PATH", g_proton.bin_dir, ":") def check_environment(self, env_name, config_name): - if not env_name in self.env: + if env_name not in self.env: return False if nonzero(self.env[env_name]): self.compat_config.add(config_name) @@ -1305,7 +1305,7 @@ class Session: #SteamGameId is not always available lfile_path = basedir + "/steam-proton.log" else: - if not "SteamGameId" in os.environ: + if "SteamGameId" not in os.environ: return False lfile_path = basedir + "/steam-" + os.environ["SteamGameId"] + ".log" @@ -1326,7 +1326,7 @@ class Session: try: import user_settings for key, value in user_settings.user_settings.items(): - if not key in self.env: + if key not in self.env: self.env[key] = value used_user_settings[key] = value except: @@ -1383,7 +1383,7 @@ class Session: else: self.env["WINEESYNC"] = "1" - if not "noxim" in self.compat_config: + if "noxim" not in self.compat_config: self.env.pop("WINE_ALLOW_XIM") if "nofsync" in self.compat_config: @@ -1419,7 +1419,7 @@ class Session: append_to_env_str(self.env, "VKD3D_CONFIG", "force_bindless_texel_buffer", ",") if "vkd3dfl12" in self.compat_config: - if not "VKD3D_FEATURE_LEVEL" in self.env: + if "VKD3D_FEATURE_LEVEL" not in self.env: self.env["VKD3D_FEATURE_LEVEL"] = "12_0" if "hidevggpu" in self.compat_config: @@ -1564,7 +1564,7 @@ class Session: return rc if __name__ == "__main__": - if not "STEAM_COMPAT_DATA_PATH" in os.environ: + if "STEAM_COMPAT_DATA_PATH" not in os.environ: log("No compat data path?") sys.exit(1) From 9e4a12cbaa9a5aa60b3f480e172c7bf59977f713 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Thu, 25 Jul 2024 12:40:25 +0300 Subject: [PATCH 056/141] proton: Use _ for ignored values. --- proton | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/proton b/proton index 214efcc377..67cd0da31c 100755 --- a/proton +++ b/proton @@ -523,7 +523,7 @@ class CompatData: try: old_proton_ver, old_prefix_ver = old_ver.split('-') old_proton_maj, old_proton_min = old_proton_ver.split('.') - new_proton_ver, new_prefix_ver = CURRENT_PREFIX_VERSION.split('-') + new_proton_ver, _ = CURRENT_PREFIX_VERSION.split('-') new_proton_maj, new_proton_min = new_proton_ver.split('.') if int(new_proton_maj) < int(old_proton_maj) or \ @@ -687,7 +687,7 @@ class CompatData: for line in tracked_files: prev_tracked_files.add(line.strip()) with open(self.tracked_files_file, "a") as tracked_files: - for src_dir, dirs, files in os.walk(g_proton.default_pfx_dir): + for src_dir, _, files in os.walk(g_proton.default_pfx_dir): rel_dir = src_dir.replace(g_proton.default_pfx_dir, "", 1).lstrip('/') if len(rel_dir) > 0: rel_dir = rel_dir + "/" @@ -1214,10 +1214,10 @@ class Session: config = os.environ["STEAM_COMPAT_CONFIG"] while config: - (cur, sep, config) = config.partition(',') + (cur, _, config) = config.partition(',') if cur.startswith("cmdlineappend:"): while comma_escaped(cur): - (a, b, c) = config.partition(',') + (a, _, c) = config.partition(',') cur = cur[:-1] + ',' + a config = c self.cmdlineappend.append(cur[14:].replace('\\\\','\\')) From 5b99c12aedc92b60ee58c1cffb87c4fe287ba023 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 10:05:48 +0300 Subject: [PATCH 057/141] proton: Use None instead of False for default argument value. This fixes type inference - tools no longer assume that there's a possibility of the value ever being True. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 67cd0da31c..96f7212e28 100755 --- a/proton +++ b/proton @@ -141,7 +141,7 @@ def merge_user_dir(src, dst): extant_dirs += dst_dir def try_copy(src, dst, prefix=None, add_write_perm=True, copy_metadata=False, optional=False, - follow_symlinks=True, track_file=False, link_debug=False): + follow_symlinks=True, track_file=None, link_debug=False): try: if prefix is not None: dst = os.path.join(prefix, dst) From 40b964bd302560f7ec9d591779d862f6c6c8dc0b Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 10:07:54 +0300 Subject: [PATCH 058/141] proton: Don't try track .debug files if there's not tracking file. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 96f7212e28..fe348126e7 100755 --- a/proton +++ b/proton @@ -173,7 +173,7 @@ def try_copy(src, dst, prefix=None, add_write_perm=True, copy_metadata=False, op if file_exists(dst + '.debug', follow_symlinks=False): os.remove(dst + '.debug') - elif link_debug: + elif link_debug and track_file: track_file.write(os.path.relpath(dst + '.debug', prefix) + '\n') if link_debug: From 73c8213f1bbb33f4f9abdc9339ebd9cb34ce071f Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 13:36:19 +0300 Subject: [PATCH 059/141] proton: Access env variables directly when we know they are set. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index fe348126e7..75b4dbf448 100755 --- a/proton +++ b/proton @@ -1487,7 +1487,7 @@ class Session: self.env["WINEDEBUG"] = "-all" if "PROTON_REMOTE_DEBUG_CMD" in self.env: - self.remote_debug_cmd = shlex.split(self.env.get("PROTON_REMOTE_DEBUG_CMD")) + self.remote_debug_cmd = shlex.split(self.env["PROTON_REMOTE_DEBUG_CMD"]) else: self.remote_debug_cmd = None From b2508139c2349e5207f163fc81c2b58e8b69d73b Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 13:46:35 +0300 Subject: [PATCH 060/141] proton: Use more meaningful variable names. --- proton | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/proton b/proton index 75b4dbf448..47b45a2ab6 100755 --- a/proton +++ b/proton @@ -269,9 +269,9 @@ def try_get_game_library_dir(): #find library path which is a subset of the game path library_paths = g_session.env["STEAM_COMPAT_LIBRARY_PATHS"].split(":") - for l in library_paths: - if l in g_session.env["STEAM_COMPAT_INSTALL_PATH"]: - return l + for path in library_paths: + if path in g_session.env["STEAM_COMPAT_INSTALL_PATH"]: + return path return None @@ -1289,10 +1289,10 @@ class Session: try: if "PRESSURE_VESSEL_RUNTIME_BASE" in self.env: with open(self.env["PRESSURE_VESSEL_RUNTIME_BASE"] + "/VERSIONS.txt", "r") as f: - for l in f: - l = l.strip() - if len(l) > 0 and not l.startswith("#"): - cleaned = l.split("#")[0].strip().replace("\t", " ") + for line in f: + line = line.strip() + if len(line) > 0 and not line.startswith("#"): + cleaned = line.split("#")[0].strip().replace("\t", " ") split = cleaned.split(" ", maxsplit=1) self.log_file.write(split[0] + ": " + split[1] + "\n") except (OSError, IOError, TypeError, KeyError): From 9fcb2d183a0b109d1d569d6250058aaba7a8a65e Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 13:51:32 +0300 Subject: [PATCH 061/141] proton: Stop using bare except. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 47b45a2ab6..16d2b66ce7 100755 --- a/proton +++ b/proton @@ -1329,7 +1329,7 @@ class Session: if key not in self.env: self.env[key] = value used_user_settings[key] = value - except: + except Exception: log("************************************************") log("THERE IS AN ERROR IN YOUR user_settings.py FILE:") log("%s" % sys.exc_info()[1]) From 0f94a21b5e298e61008436637360f3da124af25b Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 13:52:45 +0300 Subject: [PATCH 062/141] proton: Don't assign exception to a variable when the value is not used. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 16d2b66ce7..7eb51faaa8 100755 --- a/proton +++ b/proton @@ -1556,7 +1556,7 @@ class Session: remote_debug_proc.kill() try: remote_debug_proc.communicate(2) - except subprocess.TimeoutExpired as e: + except subprocess.TimeoutExpired: log("terminate remote debugger") remote_debug_proc.terminate() remote_debug_proc.communicate() From b6eda24974b395f5adf72c4f6ac6e6dd54534daa Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Fri, 26 Jul 2024 13:53:49 +0300 Subject: [PATCH 063/141] proton: Suppress type checker errors about non-existing user_settings. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 7eb51faaa8..2cd431155c 100755 --- a/proton +++ b/proton @@ -1324,7 +1324,7 @@ class Session: used_user_settings = {} if file_exists(g_proton.user_settings_file, follow_symlinks=True): try: - import user_settings + import user_settings # pyright: ignore [reportMissingImports] for key, value in user_settings.user_settings.items(): if key not in self.env: self.env[key] = value From 7fa4b63735fa38532c104cc62786b4d676a8b91a Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Mon, 29 Jul 2024 12:10:50 +0300 Subject: [PATCH 064/141] proton: Correctly Popen.communicate() with timeout. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 2cd431155c..8bec9466c9 100755 --- a/proton +++ b/proton @@ -1555,7 +1555,7 @@ class Session: if remote_debug_proc: remote_debug_proc.kill() try: - remote_debug_proc.communicate(2) + remote_debug_proc.communicate(timeout=2) except subprocess.TimeoutExpired: log("terminate remote debugger") remote_debug_proc.terminate() From a441af6e289b7c3c75eed2476d26ac776e46046e Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Mon, 22 Jul 2024 19:43:42 +0000 Subject: [PATCH 065/141] proton: Check for low file descriptor limit. CW-Bug-Id: #24035 --- proton | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/proton b/proton index 8bec9466c9..6f94bdc8b4 100755 --- a/proton +++ b/proton @@ -9,6 +9,7 @@ import os import shutil import errno import platform +import resource import stat import subprocess import sys @@ -1481,6 +1482,11 @@ class Session: if var in self.env: self.log_file.write("Effective " + var + ": " + self.env[var] + "\n") + # check for low fd limit + _soft_limit, hard_limit = resource.getrlimit(resource.RLIMIT_NOFILE) + if hard_limit < 524288: + self.log_file.write(f"WARNING: Low file descriptor limit: {hard_limit}\n") + self.log_file.write("======================\n") self.log_file.flush() else: From 95a1b7c26013f85feab88aa203e176bce0105475 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 30 Jul 2024 14:32:39 -0600 Subject: [PATCH 066/141] proton: Use server sync for RAID: World War II. CW-Bug-Id: #414740 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 6f94bdc8b4..39ffc90cc8 100755 --- a/proton +++ b/proton @@ -1122,6 +1122,7 @@ def default_compat_config(): if appid in [ "2630", #Call of Duty 2 "1060210", #Disaster Report 4: Summer Memories + "414740", #RAID: World War II ]: ret.add("nofsync") ret.add("noesync") From 86c2c1e2a13bfb7476844a0d9776d27c699ed46d Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 30 Jul 2024 15:14:50 -0600 Subject: [PATCH 067/141] proton: Enable gamedrive compat option for Strip Fighter ZERO. CW-Bug-Id: #24096 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 39ffc90cc8..3170b560e3 100755 --- a/proton +++ b/proton @@ -1099,6 +1099,7 @@ def default_compat_config(): "273590", #Descent 3 "834530", #Yakuza Kiwami "714010", #Aimlabs + "2249070", #Strip Fighter ZERO ]: ret.add("gamedrive") From f5618038c82e991c061da58cc4186a572c73fdb4 Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Tue, 30 Jul 2024 21:32:15 +0000 Subject: [PATCH 068/141] proton: Add documentation URL for file descriptor limit warning. --- proton | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proton b/proton index 3170b560e3..c66b411793 100755 --- a/proton +++ b/proton @@ -1487,7 +1487,7 @@ class Session: # check for low fd limit _soft_limit, hard_limit = resource.getrlimit(resource.RLIMIT_NOFILE) if hard_limit < 524288: - self.log_file.write(f"WARNING: Low file descriptor limit: {hard_limit}\n") + self.log_file.write(f"WARNING: Low file descriptor limit: {hard_limit} (see https://github.com/ValveSoftware/Proton/wiki/File-Descriptors)\n") self.log_file.write("======================\n") self.log_file.flush() From d47668908edc0c0d9cf56b48828261645a11caaa Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 31 Jul 2024 14:42:58 -0600 Subject: [PATCH 069/141] proton: Use server sync for Flatout 3. CW-Bug-Id: #24102 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index c66b411793..e8f6eb7a06 100755 --- a/proton +++ b/proton @@ -1124,6 +1124,7 @@ def default_compat_config(): "2630", #Call of Duty 2 "1060210", #Disaster Report 4: Summer Memories "414740", #RAID: World War II + "201510", #Flatout 3 ]: ret.add("nofsync") ret.add("noesync") From 6d9ebe28de2504f27fbf58c511312546373eba94 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 1 Aug 2024 21:29:44 -0600 Subject: [PATCH 070/141] proton: Force 32 bit steam.exe for Undecember. CW-Bug-Id: #24110 --- proton | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/proton b/proton index e8f6eb7a06..4ab2803518 100755 --- a/proton +++ b/proton @@ -1554,7 +1554,10 @@ class Session: remote_debug_proc = None # CoD: Black Ops 3 workaround - if os.environ.get("SteamGameId", 0) == "311210": + if os.environ.get("SteamGameId", 0) in [ + "311210", # CoD: Black Ops 3 + "1549250", # Undecember + ]: argv = [g_proton.wine_bin, "c:\\Program Files (x86)\\Steam\\steam.exe"] else: argv = [g_proton.wine64_bin, "c:\\windows\\system32\\steam.exe"] From 4891e6a4d9a371a4f1204abfcb49b2fd7f406f0d Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Mon, 5 Aug 2024 21:03:59 -0500 Subject: [PATCH 071/141] proton: Enable gamedrive compat option for Sword of Convallaria Option allows EULA to display properly. CW-Bug-ID: #22421 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 4ab2803518..b110c4d792 100755 --- a/proton +++ b/proton @@ -1100,6 +1100,7 @@ def default_compat_config(): "834530", #Yakuza Kiwami "714010", #Aimlabs "2249070", #Strip Fighter ZERO + "2526380", #Sword of Convallaria ]: ret.add("gamedrive") From 3876e38a89dad67ffeac422a6183de0056129802 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Tue, 6 Aug 2024 11:57:58 -0500 Subject: [PATCH 072/141] proton: Add comment to explain STEAM_COMPAT_APP_ID option in os.environ --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index b110c4d792..6faa66b73b 100755 --- a/proton +++ b/proton @@ -1158,6 +1158,7 @@ def default_compat_config(): ]: ret.add("hideapu") + #options to also be enabled for prerequisite setup steps if "STEAM_COMPAT_APP_ID" in os.environ: appid = os.environ["STEAM_COMPAT_APP_ID"] if appid in [ From 569828dc8c18bf67ab746065b0e0ce48513a5d4a Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Thu, 15 Aug 2024 18:47:59 +0300 Subject: [PATCH 073/141] Revert "proton: Add PROTON_NO_STEAM_FFMPEG to ignore ffmpeg that ships with Steam." This reverts commit 5720dd3e9c3130f65609310bf621897b9d025765. --- README.md | 1 - proton | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/README.md b/README.md index 730e39995a..03b368faca 100644 --- a/README.md +++ b/README.md @@ -309,7 +309,6 @@ the Wine prefix. Removing the option will revert to the previous behavior. | `hidenvgpu` | `PROTON_HIDE_NVIDIA_GPU` | Force Nvidia GPUs to always be reported as AMD GPUs. Some games require this if they depend on Windows-only Nvidia driver functionality. See also DXVK's nvapiHack config, which only affects reporting from Direct3D. | | | `WINE_FULLSCREEN_INTEGER_SCALING` | Enable integer scaling mode, to give sharp pixels when upscaling. | | `cmdlineappend:` | | Append the string after the colon as an argument to the game command. May be specified more than once. Escape commas and backslashes with a backslash. | -| `nosteamffmpeg` | `PROTON_NO_STEAM_FFMPEG` | Ignore ffmpeg that ships with Steam. Some videos may not play. | | `xalia` | `PROTON_USE_XALIA` | Enable Xalia, a program that can add a gamepad UI for some keyboard/mouse interfaces. | | `seccomp` | `PROTON_USE_SECCOMP` | **Note: Obsoleted in Proton 5.13.** In older versions, enable seccomp-bpf filter to emulate native syscalls, required for some DRM protections to work. | | `d9vk` | `PROTON_USE_D9VK` | **Note: Obsoleted in Proton 5.0.** In older versions, use Vulkan-based DXVK instead of OpenGL-based wined3d for d3d9. | diff --git a/proton b/proton index 6faa66b73b..9b47bd01df 100755 --- a/proton +++ b/proton @@ -1001,9 +1001,7 @@ class CompatData: setup_steam_dir_drive() # add Steam ffmpeg libraries to path - use_ffmpeg = "PROTON_NO_STEAM_FFMPEG" not in os.environ or not nonzero(os.environ["PROTON_NO_STEAM_FFMPEG"]) - if use_ffmpeg and 'nosteamffmpeg' not in g_session.compat_config: - prepend_to_env_str(g_session.env, ld_path_var, steamdir + "/ubuntu12_64/video/:" + steamdir + "/ubuntu12_32/video/", ":") + prepend_to_env_str(g_session.env, ld_path_var, steamdir + "/ubuntu12_64/video/:" + steamdir + "/ubuntu12_32/video/", ":") def comma_escaped(s): escaped = False From 95282c80a85d4214ceec7ad0e63998b11c4dbe84 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 21 Aug 2024 17:57:55 -0600 Subject: [PATCH 074/141] proton: Check for low /proc/sys/vm/max_map_count. CW-Bug-Id: #24081 --- proton | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/proton b/proton index 9b47bd01df..342aa04503 100755 --- a/proton +++ b/proton @@ -1490,6 +1490,12 @@ class Session: if hard_limit < 524288: self.log_file.write(f"WARNING: Low file descriptor limit: {hard_limit} (see https://github.com/ValveSoftware/Proton/wiki/File-Descriptors)\n") + if os.path.exists("/proc/sys/vm/max_map_count"): + with open("/proc/sys/vm/max_map_count", "r") as f: + max_map_count = int(f.read()) + if max_map_count < 1048576: + self.log_file.write(f"WARNING: Low /proc/sys/vm/max_map_count: {max_map_count} will prevent some games from working\n") + self.log_file.write("======================\n") self.log_file.flush() else: From 2f39b2e07403ccb707a17918c5d5984cedebedb8 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 27 Aug 2024 16:58:12 -0600 Subject: [PATCH 075/141] lsteamclient: Handle error result in networking_message_pool_receive_(). CW-Bug-Id: #24177 --- lsteamclient/steam_networking_manual.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/lsteamclient/steam_networking_manual.c b/lsteamclient/steam_networking_manual.c index 83ada55549..37636a4d09 100644 --- a/lsteamclient/steam_networking_manual.c +++ b/lsteamclient/steam_networking_manual.c @@ -88,6 +88,8 @@ static BOOL networking_message_pool_receive_144( int32_t capacity, int32_t count struct networking_message_pool *pool = CONTAINING_RECORD( messages[0], struct networking_message, w_msg_144 )->pool; int32_t i; + if (count < 0) count = 0; + for (i = count; i < capacity; i++) { messages[i]->m_pfnRelease( messages[i] ); @@ -155,11 +157,13 @@ static BOOL networking_message_pool_create_147( uint32_t count, w_SteamNetworkin return TRUE; } -static BOOL networking_message_pool_receive_147( uint32_t capacity, uint32_t count, w_SteamNetworkingMessage_t_147 **messages ) +static BOOL networking_message_pool_receive_147( uint32_t capacity, int32_t count, w_SteamNetworkingMessage_t_147 **messages ) { struct networking_message_pool *pool = CONTAINING_RECORD( messages[0], struct networking_message, w_msg_147 )->pool; uint32_t i; + if (count < 0) count = 0; + for (i = count; i < capacity; i++) { messages[i]->m_pfnRelease( messages[i] ); @@ -227,11 +231,13 @@ static BOOL networking_message_pool_create_153a( uint32_t count, w_SteamNetworki return TRUE; } -static BOOL networking_message_pool_receive_153a( uint32_t capacity, uint32_t count, w_SteamNetworkingMessage_t_153a **messages ) +static BOOL networking_message_pool_receive_153a( uint32_t capacity, int32_t count, w_SteamNetworkingMessage_t_153a **messages ) { struct networking_message_pool *pool = CONTAINING_RECORD( messages[0], struct networking_message, w_msg_153a )->pool; uint32_t i; + if (count < 0) count = 0; + for (i = count; i < capacity; i++) { messages[i]->m_pfnRelease( messages[i] ); From 825585de4c7b0431a148a205cba6821afe2eb7cf Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 29 Aug 2024 11:03:06 -0600 Subject: [PATCH 076/141] proton: Do not copy SXS runtime redists. CW-Bug-Id: #23227 --- proton | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/proton b/proton index 342aa04503..5c6fc6db7c 100755 --- a/proton +++ b/proton @@ -821,11 +821,17 @@ class CompatData: "xinput*.dll," + #vcruntime redist - "atl*.dll," + + "atl1*.dll," + + "atl.dll," + "concrt*.dll," + - "msvcp*.dll," + - "msvcr*.dll," + - "msvcm*.dll," + + "msvcp1*.dll," + + "msvcrt*.dll," + + "msvcp7*.dll," + + "msvcp6*.dll," + + "msvcp_win.dll," + + "msvcr1*.dll," + + "msvcrt*.dll," + + "msvcr7*.dll," + "vcamp1*.dll," + "vcomp1*.dll," + "vccorlib1*.dll," + From 97e5f6f677a6e339ebdd3fb5eae3299ab0a8d44f Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Wed, 4 Sep 2024 11:49:10 -0500 Subject: [PATCH 077/141] proton: Enable gamedrive compat option for Yakuza 3 and Yakuza 4 CW-Bug-ID: #24211 --- proton | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proton b/proton index 5c6fc6db7c..b6bb6a79e2 100755 --- a/proton +++ b/proton @@ -1102,6 +1102,8 @@ def default_compat_config(): "460790", #Bayonetta "273590", #Descent 3 "834530", #Yakuza Kiwami + "1088710", #Yakuza 3 Remastered + "1105500", #Yakuza 4 Remastered "714010", #Aimlabs "2249070", #Strip Fighter ZERO "2526380", #Sword of Convallaria From 16dbf51c57157e75633e1b7e924b11661638c039 Mon Sep 17 00:00:00 2001 From: Liam Middlebrook Date: Mon, 9 Sep 2024 17:12:05 -0700 Subject: [PATCH 078/141] proton: Populate NVIDIA_WINE_DLL_DIR when available NVIDIA-software may check the environment variable `NVIDIA_WINE_DLL_DIR` for a path where DLLs provided by the NVIDIA Linux driver can be found. This needs to be set by `proton` script, as it is ran inside of the pressure-vessel environment, so the paths returned will be valid within the environment. Tested with an application that reads `NVIDIA_WINE_DLL_DIR` from the environment and tries to load a known DLL from it. As expected manually setting the environment variable to the on-disk location did not work, as the path is not accurate within the pressure-vessel environment. https://github.com/ValveSoftware/Proton/pull/8087 --- proton | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/proton b/proton index b6bb6a79e2..e8b36f896c 100755 --- a/proton +++ b/proton @@ -1461,6 +1461,12 @@ class Session: if "PROTON_CRASH_REPORT_DIR" in self.env: self.env["WINE_CRASH_REPORT_DIR"] = self.env["PROTON_CRASH_REPORT_DIR"] + # NVIDIA software may check NVIDIA_WINE_DLL_DIR as a search-path for + # driver-provided DLLs for use by Proton/Wine. + nvidia_wine_dll_dir = find_nvidia_wine_dll_dir() + if nvidia_wine_dll_dir: + self.env["NVIDIA_WINE_DLL_DIR"] = nvidia_wine_dll_dir + if "PROTON_LOG" in self.env and nonzero(self.env["PROTON_LOG"]): if self.setup_logging(append_forever=False): self.log_file.write("======================\n") From ef6f55844d79c459ed36b34b098f91544d8932de Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Tue, 10 Sep 2024 20:40:29 +0000 Subject: [PATCH 079/141] Update Wine Mono to 9.3.0. --- Makefile.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index ae4df5e97e..1278dc39e3 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1040,7 +1040,7 @@ all-dist: $(DIST_GECKO32) $(DIST_GECKO64) ## wine-mono ## -WINEMONO_VER := 9.2.0 +WINEMONO_VER := 9.3.0 WINEMONO_TARBALL := wine-mono-$(WINEMONO_VER)-x86.tar.xz DIST_WINEMONO_DIR := $(DST_DIR)/share/wine/mono DIST_WINEMONO := $(OBJ)/.wine-mono-dist From c506aff6953ebe2abde823a979290573690d82ee Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 11 Sep 2024 14:53:33 -0600 Subject: [PATCH 080/141] lsteamclient: Convert URL in ISteamFriends::ActivateGameOverlayToWebPage(). CW-Bug-Id: #24247 --- lsteamclient/cppISteamFriends_SteamFriends005.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends006.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends007.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends008.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends009.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends010.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends011.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends012.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends013.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends014.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends015.cpp | 4 +++- lsteamclient/cppISteamFriends_SteamFriends017.cpp | 4 +++- lsteamclient/gen_wrapper.py | 3 +++ 13 files changed, 39 insertions(+), 12 deletions(-) diff --git a/lsteamclient/cppISteamFriends_SteamFriends005.cpp b/lsteamclient/cppISteamFriends_SteamFriends005.cpp index 352cfa8b4f..76847ffb2d 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends005.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends005.cpp @@ -177,7 +177,9 @@ NTSTATUS ISteamFriends_SteamFriends005_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends005_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends005_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends005 *iface = (struct u_ISteamFriends_SteamFriends005 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends006.cpp b/lsteamclient/cppISteamFriends_SteamFriends006.cpp index 289b82f72a..6d88023322 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends006.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends006.cpp @@ -185,7 +185,9 @@ NTSTATUS ISteamFriends_SteamFriends006_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends006_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends006_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends006 *iface = (struct u_ISteamFriends_SteamFriends006 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends007.cpp b/lsteamclient/cppISteamFriends_SteamFriends007.cpp index 7373c08996..d1e484dc04 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends007.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends007.cpp @@ -177,7 +177,9 @@ NTSTATUS ISteamFriends_SteamFriends007_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends007_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends007_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends007 *iface = (struct u_ISteamFriends_SteamFriends007 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends008.cpp b/lsteamclient/cppISteamFriends_SteamFriends008.cpp index ebd6836ad0..f567263460 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends008.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends008.cpp @@ -177,7 +177,9 @@ NTSTATUS ISteamFriends_SteamFriends008_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends008_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends008_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends008 *iface = (struct u_ISteamFriends_SteamFriends008 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends009.cpp b/lsteamclient/cppISteamFriends_SteamFriends009.cpp index 13910adf85..3e67fb0a72 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends009.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends009.cpp @@ -177,7 +177,9 @@ NTSTATUS ISteamFriends_SteamFriends009_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends009_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends009_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends009 *iface = (struct u_ISteamFriends_SteamFriends009 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends010.cpp b/lsteamclient/cppISteamFriends_SteamFriends010.cpp index dbeb612b0a..f5b63ada9c 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends010.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends010.cpp @@ -193,7 +193,9 @@ NTSTATUS ISteamFriends_SteamFriends010_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends010_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends010_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends010 *iface = (struct u_ISteamFriends_SteamFriends010 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends011.cpp b/lsteamclient/cppISteamFriends_SteamFriends011.cpp index fc25754002..be388cf673 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends011.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends011.cpp @@ -193,7 +193,9 @@ NTSTATUS ISteamFriends_SteamFriends011_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends011_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends011_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends011 *iface = (struct u_ISteamFriends_SteamFriends011 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends012.cpp b/lsteamclient/cppISteamFriends_SteamFriends012.cpp index 0e724faa18..34602e5ec3 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends012.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends012.cpp @@ -193,7 +193,9 @@ NTSTATUS ISteamFriends_SteamFriends012_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends012_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends012_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends012 *iface = (struct u_ISteamFriends_SteamFriends012 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends013.cpp b/lsteamclient/cppISteamFriends_SteamFriends013.cpp index e5443acb63..6ebba6c9de 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends013.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends013.cpp @@ -193,7 +193,9 @@ NTSTATUS ISteamFriends_SteamFriends013_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends013_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends013_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends013 *iface = (struct u_ISteamFriends_SteamFriends013 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends014.cpp b/lsteamclient/cppISteamFriends_SteamFriends014.cpp index e687894ed5..ee06f5c230 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends014.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends014.cpp @@ -201,7 +201,9 @@ NTSTATUS ISteamFriends_SteamFriends014_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends014_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends014_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends014 *iface = (struct u_ISteamFriends_SteamFriends014 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends015.cpp b/lsteamclient/cppISteamFriends_SteamFriends015.cpp index ea3031be84..f74973e377 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends015.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends015.cpp @@ -249,7 +249,9 @@ NTSTATUS ISteamFriends_SteamFriends015_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends015_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends015_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends015 *iface = (struct u_ISteamFriends_SteamFriends015 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/cppISteamFriends_SteamFriends017.cpp b/lsteamclient/cppISteamFriends_SteamFriends017.cpp index 20d9a97fb4..c530b0f81e 100644 --- a/lsteamclient/cppISteamFriends_SteamFriends017.cpp +++ b/lsteamclient/cppISteamFriends_SteamFriends017.cpp @@ -249,7 +249,9 @@ NTSTATUS ISteamFriends_SteamFriends017_ActivateGameOverlayToWebPage( void *args { struct ISteamFriends_SteamFriends017_ActivateGameOverlayToWebPage_params *params = (struct ISteamFriends_SteamFriends017_ActivateGameOverlayToWebPage_params *)args; struct u_ISteamFriends_SteamFriends017 *iface = (struct u_ISteamFriends_SteamFriends017 *)params->linux_side; - iface->ActivateGameOverlayToWebPage( params->pchURL, params->eMode ); + char *u_pchURL = steamclient_dos_to_unix_path( params->pchURL, 1 ); + iface->ActivateGameOverlayToWebPage( u_pchURL, params->eMode ); + steamclient_free_path( u_pchURL ); return 0; } diff --git a/lsteamclient/gen_wrapper.py b/lsteamclient/gen_wrapper.py index c21733bdc1..637532dbd1 100755 --- a/lsteamclient/gen_wrapper.py +++ b/lsteamclient/gen_wrapper.py @@ -382,6 +382,9 @@ def is_manual_method(klass, method, abi): "ISteamInput_SetInputActionManifestFilePath": { "pchInputActionManifestAbsolutePath": {"array": False, "url": False}, }, + "ISteamFriends_ActivateGameOverlayToWebPage": { + "pchURL": {"array": False, "url": True}, + }, } PATH_CONV_STRUCTS = { From f0364fcfd80bd9081b79758e93b79fa950037952 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Fri, 20 Sep 2024 14:09:03 -0600 Subject: [PATCH 081/141] lsteamclient: Add ISteamTimeline interface. CW-Bug-Id: #24276 --- lsteamclient/Makefile.in | 2 + ...mTimeline_STEAMTIMELINE_INTERFACE_V001.cpp | 39 ++++++++ lsteamclient/gen_wrapper.py | 3 + lsteamclient/steamclient_generated.c | 3 + lsteamclient/steamclient_generated.h | 1 + lsteamclient/steamclient_structs_generated.h | 26 ------ lsteamclient/unix_private_generated.h | 14 +++ lsteamclient/unixlib_generated.cpp | 4 + lsteamclient/unixlib_generated.h | 35 +++++++ lsteamclient/winISteamTimeline.c | 93 +++++++++++++++++++ 10 files changed, 194 insertions(+), 26 deletions(-) create mode 100644 lsteamclient/cppISteamTimeline_STEAMTIMELINE_INTERFACE_V001.cpp create mode 100644 lsteamclient/winISteamTimeline.c diff --git a/lsteamclient/Makefile.in b/lsteamclient/Makefile.in index 94a10c255a..e8e13a9b99 100644 --- a/lsteamclient/Makefile.in +++ b/lsteamclient/Makefile.in @@ -40,6 +40,7 @@ SOURCES = \ winISteamRemotePlay.c \ winISteamRemoteStorage.c \ winISteamScreenshots.c \ + winISteamTimeline.c \ winISteamUGC.c \ winISteamUnifiedMessages.c \ winISteamUser.c \ @@ -182,6 +183,7 @@ SOURCES = \ cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION001.cpp \ cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION002.cpp \ cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003.cpp \ + cppISteamTimeline_STEAMTIMELINE_INTERFACE_V001.cpp \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION001.cpp \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION002.cpp \ cppISteamUGC_STEAMUGC_INTERFACE_VERSION003.cpp \ diff --git a/lsteamclient/cppISteamTimeline_STEAMTIMELINE_INTERFACE_V001.cpp b/lsteamclient/cppISteamTimeline_STEAMTIMELINE_INTERFACE_V001.cpp new file mode 100644 index 0000000000..3fb0cfefe9 --- /dev/null +++ b/lsteamclient/cppISteamTimeline_STEAMTIMELINE_INTERFACE_V001.cpp @@ -0,0 +1,39 @@ +/* This file is auto-generated, do not edit. */ +#include "unix_private.h" + +#if 0 +#pragma makedep unix +#endif + +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription( void *args ) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription_params *params = (struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription_params *)args; + struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *iface = (struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *)params->linux_side; + iface->SetTimelineStateDescription( params->pchDescription, params->flTimeDelta ); + return 0; +} + +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription( void *args ) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription_params *params = (struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription_params *)args; + struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *iface = (struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *)params->linux_side; + iface->ClearTimelineStateDescription( params->flTimeDelta ); + return 0; +} + +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent( void *args ) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent_params *params = (struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent_params *)args; + struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *iface = (struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *)params->linux_side; + iface->AddTimelineEvent( params->pchIcon, params->pchTitle, params->pchDescription, params->unPriority, params->flStartOffsetSeconds, params->flDurationSeconds, params->ePossibleClip ); + return 0; +} + +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode( void *args ) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode_params *params = (struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode_params *)args; + struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *iface = (struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 *)params->linux_side; + iface->SetTimelineGameMode( params->eMode ); + return 0; +} + diff --git a/lsteamclient/gen_wrapper.py b/lsteamclient/gen_wrapper.py index 637532dbd1..cede19067a 100755 --- a/lsteamclient/gen_wrapper.py +++ b/lsteamclient/gen_wrapper.py @@ -165,6 +165,9 @@ "steamnetworkingfakeip.h": [ "ISteamNetworkingFakeUDPPort" ], + "isteamtimeline.h": [ + "ISteamTimeline" + ], } SDK_CLASSES = {klass: source for source, klasses in SDK_SOURCES.items() diff --git a/lsteamclient/steamclient_generated.c b/lsteamclient/steamclient_generated.c index a6da3610d8..140488680f 100644 --- a/lsteamclient/steamclient_generated.c +++ b/lsteamclient/steamclient_generated.c @@ -50,6 +50,7 @@ static const struct { const char *iface_version; iface_constructor ctor; } const {"STEAMSCREENSHOTS_INTERFACE_VERSION001", &create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION001}, {"STEAMSCREENSHOTS_INTERFACE_VERSION002", &create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION002}, {"STEAMSCREENSHOTS_INTERFACE_VERSION003", &create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003}, + {"STEAMTIMELINE_INTERFACE_V001", &create_winISteamTimeline_STEAMTIMELINE_INTERFACE_V001}, {"STEAMUGC_INTERFACE_VERSION001", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION001}, {"STEAMUGC_INTERFACE_VERSION002", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION002}, {"STEAMUGC_INTERFACE_VERSION003", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION003}, @@ -251,6 +252,7 @@ extern void init_winISteamParties_rtti( char * ); extern void init_winISteamRemotePlay_rtti( char * ); extern void init_winISteamRemoteStorage_rtti( char * ); extern void init_winISteamScreenshots_rtti( char * ); +extern void init_winISteamTimeline_rtti( char * ); extern void init_winISteamUGC_rtti( char * ); extern void init_winISteamUnifiedMessages_rtti( char * ); extern void init_winISteamUser_rtti( char * ); @@ -291,6 +293,7 @@ void init_rtti( char *base ) init_winISteamRemotePlay_rtti( base ); init_winISteamRemoteStorage_rtti( base ); init_winISteamScreenshots_rtti( base ); + init_winISteamTimeline_rtti( base ); init_winISteamUGC_rtti( base ); init_winISteamUnifiedMessages_rtti( base ); init_winISteamUser_rtti( base ); diff --git a/lsteamclient/steamclient_generated.h b/lsteamclient/steamclient_generated.h index 1972915489..25a88c53ca 100644 --- a/lsteamclient/steamclient_generated.h +++ b/lsteamclient/steamclient_generated.h @@ -45,6 +45,7 @@ extern struct w_steam_iface *create_winISteamRemoteStorage_STEAMREMOTESTORAGE_IN extern struct w_steam_iface *create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION001(void *); extern struct w_steam_iface *create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION002(void *); extern struct w_steam_iface *create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003(void *); +extern struct w_steam_iface *create_winISteamTimeline_STEAMTIMELINE_INTERFACE_V001(void *); extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION001(void *); extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION002(void *); extern struct w_steam_iface *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION003(void *); diff --git a/lsteamclient/steamclient_structs_generated.h b/lsteamclient/steamclient_structs_generated.h index 33381e72b9..85d0f8418c 100644 --- a/lsteamclient/steamclient_structs_generated.h +++ b/lsteamclient/steamclient_structs_generated.h @@ -2567,12 +2567,6 @@ typedef struct u_ISteamNetworkingCustomSignalingRecvContext u32_ISteamNetworking typedef struct w_ISteamNetworkingCustomSignalingRecvContext w_ISteamNetworkingCustomSignalingRecvContext; typedef struct w_ISteamNetworkingCustomSignalingRecvContext w64_ISteamNetworkingCustomSignalingRecvContext; typedef struct w_ISteamNetworkingCustomSignalingRecvContext w32_ISteamNetworkingCustomSignalingRecvContext; -typedef struct u_ISteamTimeline u_ISteamTimeline; -typedef struct u_ISteamTimeline u64_ISteamTimeline; -typedef struct u_ISteamTimeline u32_ISteamTimeline; -typedef struct w_ISteamTimeline w_ISteamTimeline; -typedef struct w_ISteamTimeline w64_ISteamTimeline; -typedef struct w_ISteamTimeline w32_ISteamTimeline; typedef struct u64_ItemInstalled_t_160 u64_ItemInstalled_t_160; typedef struct w64_ItemInstalled_t_160 w64_ItemInstalled_t_160; typedef struct u32_ItemInstalled_t_160 u32_ItemInstalled_t_160; @@ -5861,26 +5855,6 @@ struct u_ISteamNetworkingCustomSignalingRecvContext #endif /* __cplusplus */ }; -struct w_ISteamTimeline -{ -#ifdef __cplusplus - virtual void SetTimelineStateDescription( const char *, float ) = 0; - virtual void ClearTimelineStateDescription( float ) = 0; - virtual void AddTimelineEvent( const char *, const char *, const char *, uint32_t, float, float, uint32_t ) = 0; - virtual void SetTimelineGameMode( uint32_t ) = 0; -#endif /* __cplusplus */ -}; - -struct u_ISteamTimeline -{ -#ifdef __cplusplus - virtual void SetTimelineStateDescription( const char *, float ) = 0; - virtual void ClearTimelineStateDescription( float ) = 0; - virtual void AddTimelineEvent( const char *, const char *, const char *, uint32_t, float, float, uint32_t ) = 0; - virtual void SetTimelineGameMode( uint32_t ) = 0; -#endif /* __cplusplus */ -}; - #pragma pack( push, 8 ) struct w64_ItemInstalled_t_160 { diff --git a/lsteamclient/unix_private_generated.h b/lsteamclient/unix_private_generated.h index 17cf815dab..753c48979c 100644 --- a/lsteamclient/unix_private_generated.h +++ b/lsteamclient/unix_private_generated.h @@ -7189,6 +7189,16 @@ struct u_ISteamUGC_STEAMUGC_INTERFACE_VERSION020 #endif /* __cplusplus */ }; +struct u_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001 +{ +#ifdef __cplusplus + virtual void SetTimelineStateDescription( const char *, float ) = 0; + virtual void ClearTimelineStateDescription( float ) = 0; + virtual void AddTimelineEvent( const char *, const char *, const char *, uint32_t, float, float, uint32_t ) = 0; + virtual void SetTimelineGameMode( uint32_t ) = 0; +#endif /* __cplusplus */ +}; + struct u_ISteamVideo_STEAMVIDEO_INTERFACE_V007 { #ifdef __cplusplus @@ -8372,6 +8382,10 @@ NTSTATUS ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_TagUser( void * NTSTATUS ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_TagPublishedFile( void * ); NTSTATUS ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_IsScreenshotsHooked( void * ); NTSTATUS ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_AddVRScreenshotToLibrary( void * ); +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription( void * ); +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription( void * ); +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent( void * ); +NTSTATUS ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryUserUGCRequest( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryAllUGCRequest( void * ); NTSTATUS ISteamUGC_STEAMUGC_INTERFACE_VERSION001_SendQueryUGCRequest( void * ); diff --git a/lsteamclient/unixlib_generated.cpp b/lsteamclient/unixlib_generated.cpp index ee8511ad39..4429ea119b 100644 --- a/lsteamclient/unixlib_generated.cpp +++ b/lsteamclient/unixlib_generated.cpp @@ -1195,6 +1195,10 @@ extern "C" const unixlib_entry_t __wine_unix_call_funcs[] = ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_TagPublishedFile, ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_IsScreenshotsHooked, ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_AddVRScreenshotToLibrary, + ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription, + ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription, + ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent, + ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode, ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryUserUGCRequest, ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryAllUGCRequest, ISteamUGC_STEAMUGC_INTERFACE_VERSION001_SendQueryUGCRequest, diff --git a/lsteamclient/unixlib_generated.h b/lsteamclient/unixlib_generated.h index bc8d7de14f..23baef4871 100644 --- a/lsteamclient/unixlib_generated.h +++ b/lsteamclient/unixlib_generated.h @@ -9010,6 +9010,37 @@ struct ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_AddVRScreenshotTo const char *pchVRFilename; }; +struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription_params +{ + struct u_steam_iface *linux_side; + const char *pchDescription; + float flTimeDelta; +}; + +struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription_params +{ + struct u_steam_iface *linux_side; + float flTimeDelta; +}; + +struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent_params +{ + struct u_steam_iface *linux_side; + const char *pchIcon; + const char *pchTitle; + const char *pchDescription; + uint32_t unPriority; + float flStartOffsetSeconds; + float flDurationSeconds; + uint32_t ePossibleClip; +}; + +struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode_params +{ + struct u_steam_iface *linux_side; + uint32_t eMode; +}; + struct ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryUserUGCRequest_params { struct u_steam_iface *linux_side; @@ -47926,6 +47957,10 @@ enum unix_funcs unix_ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_TagPublishedFile, unix_ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_IsScreenshotsHooked, unix_ISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_AddVRScreenshotToLibrary, + unix_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription, + unix_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription, + unix_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent, + unix_ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode, unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryUserUGCRequest, unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION001_CreateQueryAllUGCRequest, unix_ISteamUGC_STEAMUGC_INTERFACE_VERSION001_SendQueryUGCRequest, diff --git a/lsteamclient/winISteamTimeline.c b/lsteamclient/winISteamTimeline.c new file mode 100644 index 0000000000..1c7cac81bf --- /dev/null +++ b/lsteamclient/winISteamTimeline.c @@ -0,0 +1,93 @@ +/* This file is auto-generated, do not edit. */ +#include "steamclient_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(steamclient); + +DEFINE_THISCALL_WRAPPER(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription, 12) +DEFINE_THISCALL_WRAPPER(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription, 8) +DEFINE_THISCALL_WRAPPER(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent, 32) +DEFINE_THISCALL_WRAPPER(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode, 8) + +void __thiscall winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription(struct w_steam_iface *_this, const char *pchDescription, float flTimeDelta) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription_params params = + { + .linux_side = _this->u_iface, + .pchDescription = pchDescription, + .flTimeDelta = flTimeDelta, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchDescription, -1); + STEAMCLIENT_CALL( ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription, ¶ms ); +} + +void __thiscall winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription(struct w_steam_iface *_this, float flTimeDelta) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription_params params = + { + .linux_side = _this->u_iface, + .flTimeDelta = flTimeDelta, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription, ¶ms ); +} + +void __thiscall winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent(struct w_steam_iface *_this, const char *pchIcon, const char *pchTitle, const char *pchDescription, uint32_t unPriority, float flStartOffsetSeconds, float flDurationSeconds, uint32_t ePossibleClip) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent_params params = + { + .linux_side = _this->u_iface, + .pchIcon = pchIcon, + .pchTitle = pchTitle, + .pchDescription = pchDescription, + .unPriority = unPriority, + .flStartOffsetSeconds = flStartOffsetSeconds, + .flDurationSeconds = flDurationSeconds, + .ePossibleClip = ePossibleClip, + }; + TRACE("%p\n", _this); + IsBadStringPtrA(pchIcon, -1); + IsBadStringPtrA(pchTitle, -1); + IsBadStringPtrA(pchDescription, -1); + STEAMCLIENT_CALL( ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent, ¶ms ); +} + +void __thiscall winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode(struct w_steam_iface *_this, uint32_t eMode) +{ + struct ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode_params params = + { + .linux_side = _this->u_iface, + .eMode = eMode, + }; + TRACE("%p\n", _this); + STEAMCLIENT_CALL( ISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode, ¶ms ); +} + +extern vtable_ptr winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_vtable; + +DEFINE_RTTI_DATA0(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001, 0, ".?AVISteamTimeline@@") + +__ASM_BLOCK_BEGIN(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_vtables) + __ASM_VTABLE(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001, + VTABLE_ADD_FUNC(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineStateDescription) + VTABLE_ADD_FUNC(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_ClearTimelineStateDescription) + VTABLE_ADD_FUNC(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_AddTimelineEvent) + VTABLE_ADD_FUNC(winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_SetTimelineGameMode) + ); +__ASM_BLOCK_END + +struct w_steam_iface *create_winISteamTimeline_STEAMTIMELINE_INTERFACE_V001(void *u_iface) +{ + struct w_steam_iface *r = alloc_mem_for_iface(sizeof(struct w_steam_iface), "STEAMTIMELINE_INTERFACE_V001"); + TRACE("-> %p\n", r); + r->vtable = alloc_vtable(&winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_vtable, 4, "STEAMTIMELINE_INTERFACE_V001"); + r->u_iface = u_iface; + return r; +} + +void init_winISteamTimeline_rtti( char *base ) +{ +#ifdef __x86_64__ + init_winISteamTimeline_STEAMTIMELINE_INTERFACE_V001_rtti( base ); +#endif /* __x86_64__ */ +} From 5159bc393a9b3a68e7ee2f3af546b6be6ee9dc94 Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Wed, 14 Aug 2024 18:42:33 +0000 Subject: [PATCH 082/141] Update Xalia to 0.4.4. --- Makefile.in | 2 +- proton | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Makefile.in b/Makefile.in index 1278dc39e3..ba78d37ede 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1063,7 +1063,7 @@ all-dist: $(DIST_WINEMONO) ## xalia ## -XALIA_VER := 0.4.2 +XALIA_VER := 0.4.4 XALIA_ZIP := xalia-$(XALIA_VER)-net48-mono.zip DIST_XALIA_DIR := $(DST_DIR)/share/xalia DIST_XALIA := $(OBJ)/.xalia-dist diff --git a/proton b/proton index e8b36f896c..63a4bbe047 100755 --- a/proton +++ b/proton @@ -1169,13 +1169,18 @@ def default_compat_config(): appid = os.environ["STEAM_COMPAT_APP_ID"] if appid in [ "7000", # Tomb Raider: Legend + "7200", # Trackmania United Forever "8000", # Tomb Raider: Anniversary + "11020", # TrackMania Nations Forever + "15750", # Oddworld: Stranger's Wrath HD "22300", # Fallout 3 "22370", # Fallout 3: Game of the Year Edition + "22380", # Fallout: New Vegas "72850", # The Elder Scrolls V: Skyrim "377160", # Fallout 4 "397950", # Clustertruck "489830", # The Elder Scrolls V: Skyrim Special Edition + "610190", # WARRIORS ALL-STARS "712180", # Mugsters "1818750", # MultiVersus ]: From 1b83155c336323b1016103985ccba721ad2a4365 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Tue, 1 Oct 2024 19:13:55 -0600 Subject: [PATCH 083/141] proton: Disable nvapi for Fablecraft. CW-Bug-Id: #24325 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 63a4bbe047..040fc01a90 100755 --- a/proton +++ b/proton @@ -1151,6 +1151,7 @@ def default_compat_config(): "202750", #Alan Wake's American Nightmare "255220", #GRID Autosport "44350", #GRID 2 + "2176900", #Fablecraft ]: ret.add("disablenvapi") From 9ef062cef71bb06958d4518ac2b0b1878042dec9 Mon Sep 17 00:00:00 2001 From: Arkadiusz Hiler Date: Wed, 2 Oct 2024 17:05:16 +0300 Subject: [PATCH 084/141] update vkd3d-shader --- vkd3d | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vkd3d b/vkd3d index 68b7f9df31..3452d126a8 160000 --- a/vkd3d +++ b/vkd3d @@ -1 +1 @@ -Subproject commit 68b7f9df310a27fb8e4ebac48a1452570263ac08 +Subproject commit 3452d126a8eb82fa3f59c3832016471a85f09b40 From 5b26b6a1d4df17642c68ae883096a865fdc70bc6 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Sun, 29 Sep 2024 02:25:22 +0200 Subject: [PATCH 085/141] steam_helper: clean up OpenVR before getting OpenXR extensions in `initialize_vr_data` Patch written by Emily <102429049+emily-is-my-username@users.noreply.github.com> https://github.com/ValveSoftware/Proton/pull/8126 When using OpenComposite, both OpenVR and OpenXR functions may call the same underlying OpenXR loader. Because the OpenXR loader only supports a single active instance, `initialize_vr_data` currently fails as an OpenXR instance has already been initialized ath the time XR extensions are queried. This commit fixes the problem by cleaning up the temporary OpenVR context *before* initializing OpenXR instead of keeping it open until the end of the call. Fix for: https://github.com/ValveSoftware/Proton/issues/7905 Signed-off-by: Paul Gofman --- steam_helper/steam.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/steam_helper/steam.cpp b/steam_helper/steam.cpp index f99596bc5a..a083915e7b 100644 --- a/steam_helper/steam.cpp +++ b/steam_helper/steam.cpp @@ -893,6 +893,11 @@ static DWORD WINAPI initialize_vr_data(void *arg) } } + if (vr_initialized) { + client_core->Cleanup(); + vr_initialized = FALSE; + } + if ((hwineopenxr = LoadLibraryA("wineopenxr.dll"))) { p__wineopenxr_get_extensions_internal = reinterpret_cast From 491ca2616d415ab74c70c02b395765fa379da8cb Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 10 Oct 2024 21:34:33 -0600 Subject: [PATCH 086/141] proton: Enable WINE_HEAP_TOP_DOWN hack for Crazy Taxi. CW-Bug-Id: #24362 --- proton | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/proton b/proton index 040fc01a90..90be0d7a06 100755 --- a/proton +++ b/proton @@ -1127,6 +1127,11 @@ def default_compat_config(): ]: ret.add("heapzeromemory") + if appid in [ + "71230", #Crazy Taxi + ]: + ret.add("heaptopdown") + if appid in [ "2630", #Call of Duty 2 "1060210", #Disaster Report 4: Summer Memories @@ -1433,6 +1438,9 @@ class Session: if "heapzeromemory" in self.compat_config: self.env["WINE_HEAP_ZERO_MEMORY"] = "1" + if "heaptopdown" in self.compat_config: + self.env["WINE_HEAP_TOP_DOWN"] = "1" + if "vkd3dbindlesstb" in self.compat_config: append_to_env_str(self.env, "VKD3D_CONFIG", "force_bindless_texel_buffer", ",") From 893ac96f0ce46857a1a5e311856e927ac9ff9d56 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Tue, 22 Oct 2024 22:59:56 -0500 Subject: [PATCH 087/141] proton: Enable gamedrive compat option for STAR WARS Jedi Knight II CW-Bug-Id: #24390 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 90be0d7a06..270a8f3e8a 100755 --- a/proton +++ b/proton @@ -1107,6 +1107,7 @@ def default_compat_config(): "714010", #Aimlabs "2249070", #Strip Fighter ZERO "2526380", #Sword of Convallaria + "6030", #Star Wars - Jedi Knight II: Jedi Outcast ]: ret.add("gamedrive") From d3084bf59890635d06f32cfac237ce51b49d5ed4 Mon Sep 17 00:00:00 2001 From: Anna Lasky Date: Thu, 24 Oct 2024 09:30:58 -0500 Subject: [PATCH 088/141] proton: Disable nvapi for Hard Reset Redux CW-Bug-Id: #24396 --- proton | 1 + 1 file changed, 1 insertion(+) diff --git a/proton b/proton index 270a8f3e8a..607d1bf23d 100755 --- a/proton +++ b/proton @@ -1158,6 +1158,7 @@ def default_compat_config(): "255220", #GRID Autosport "44350", #GRID 2 "2176900", #Fablecraft + "407810", #Hard Reset Redux ]: ret.add("disablenvapi") From 41100ddecd20146b956ed2ea6df4c0cac37c8e2c Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Wed, 30 Oct 2024 11:59:52 -0600 Subject: [PATCH 089/141] proton: Preserve MachineGuid when downgrading prefix and generate unique for the new prefix. CW-Bug-Id: #24414 --- proton | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/proton b/proton index 607d1bf23d..09605c9475 100755 --- a/proton +++ b/proton @@ -14,6 +14,7 @@ import stat import subprocess import sys import shlex +import uuid from ctypes import CDLL from ctypes import CFUNCTYPE @@ -405,6 +406,57 @@ def set_dir_casefold_bit(dir_path): pass os.close(dr) +def get_replace_reg_value(file, key, name, new_value=None): + if not file_exists(file, follow_symlinks=True): + return None + replaced = False + out = None + if new_value is not None: + out = open(file + ".new", "w") + found_key = False + old_value = None + namestr="\"" + name + "\"=" + with open(file, "r") as reg_in: + for line in reg_in: + if not replaced: + if line[0] == '[': + if found_key: + if out is not None: + out.close() + return None + if line[1:len(key) + 1] == key: + found_key = True + elif found_key: + idx = line.find(namestr) + if idx != -1: + old_value = line[idx + len(namestr):] + if out is not None: + out.write(namestr + new_value) + replaced = True + continue + else: + return old_value + if out is not None: + out.write(line) + + if out is not None: + out.close() + + if replaced: + try: + os.rename(file, file + ".old") + except OSError: + os.remove(file) + pass + + try: + os.rename(file + ".new", file) + except OSError: + log("Unable to write new registry file to " + file) + pass + + return old_value + class Proton: def __init__(self, base_dir): self.base_dir = base_dir + "/" @@ -478,6 +530,7 @@ class CompatData: self.config_info_file = self.path("config_info") self.tracked_files_file = self.path("tracked_files") self.prefix_lock = FileLock(self.path("pfx.lock"), timeout=-1) + self.old_machine_guid = None def path(self, d): return self.base_dir + d @@ -531,6 +584,7 @@ class CompatData: (int(new_proton_maj) == int(old_proton_maj) and \ int(new_proton_min) < int(old_proton_min)): log("Removing newer prefix") + self.old_machine_guid = get_replace_reg_value(self.prefix_dir + "system.reg", "Software\\\\Microsoft\\\\Cryptography", "MachineGuid") if old_proton_ver == "3.7" and not file_exists(self.tracked_files_file, follow_symlinks=True): #proton 3.7 did not generate tracked_files, so copy it into place first try_copy(g_proton.path("proton_3.7_tracked_files"), self.tracked_files_file) @@ -790,6 +844,10 @@ class CompatData: if not file_exists(self.prefix_dir + "/user.reg", follow_symlinks=True): self.copy_pfx() + machine_guid = self.old_machine_guid + if machine_guid is None: + machine_guid = "\"" + str(uuid.uuid4()) + "\"" + get_replace_reg_value(self.prefix_dir + "system.reg", "Software\\\\Microsoft\\\\Cryptography", "MachineGuid", machine_guid) self.migrate_user_paths() From 27a47018bb5f3ff348f25ca11a29b4449d6df002 Mon Sep 17 00:00:00 2001 From: Paul Gofman Date: Thu, 31 Oct 2024 13:05:25 -0600 Subject: [PATCH 090/141] Makefile.in: Distribute ICU dlls (64 bit). CW-Bug-Id: #24402 --- Makefile.in | 18 ++++++++++++++++++ icu/icu-6.8.2-x86_64.tar.xz | Bin 0 -> 8621804 bytes 2 files changed, 18 insertions(+) create mode 100644 icu/icu-6.8.2-x86_64.tar.xz diff --git a/Makefile.in b/Makefile.in index ba78d37ede..e6dba04a08 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1082,6 +1082,24 @@ $(DIST_XALIA): $(SRC)/contrib/$(XALIA_ZIP) all-dist: $(DIST_XALIA) +## +## ICU +## + +ICU_VER := 6.8.2 +DIST_ICU_DIR := $(DST_DIR)/lib64/icu +DIST_ICU := $(OBJ)/.icu-dist +ICU_TARBALL := icu-$(ICU_VER)-x86_64.tar.xz + +$(DIST_ICU): $(SRC)/icu/$(ICU_TARBALL) + mkdir -p $(DIST_ICU_DIR) + rm -rf $(DIST_ICU_DIR)/*.dll + tar --no-same-owner -xf $< -C $(DIST_ICU_DIR) + touch $@ + +all-dist: $(DIST_ICU) + + ## ## openvr ## diff --git a/icu/icu-6.8.2-x86_64.tar.xz b/icu/icu-6.8.2-x86_64.tar.xz new file mode 100644 index 0000000000000000000000000000000000000000..d4f9f94557a06781269fef1884566971f0e9173c GIT binary patch literal 8621804 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�W%zb4-G9v0)klk(bA)=X@Lbw+^M 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ℑ?P2~Vnc_hS!jMKq(2kHszaO&I6?^a8-VjEq* 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�}m9|)M@P%tzH7IlRUV5xZWBsQI!l3{|gsUaTq@Sf%d*rfL*M)l=7 zE^dyyno9!YY`Uipvf*YIzjM4=?2ZYOoS6J{j!fregvFN^h?F3lG>m-rwg8dv!~P&2 zeQ=jyDyahZ(I<7J$!OT1(>$KIEe|$f>OfX8A{DYgl|Vey=M0q|E?j2*xEEJ8yP;js z>QAE^_Cv%{BT5^^${;1?UW*ojwNkNJ+Z6{1>kp}G2JAmMicv%`JkVNi%>uUHl6YcQ zLleo~&_(19nQiSWC)CS#xx{z(!UR`+Wz?+wpR1(~WH4z2H}u3l#y4itHKLBGAbLs+ z)3NSlylo`k`lzd2z?psS;yIsSu%0~DAN?x^enbod;ClWFd(BAi* zzvlDVQ|@Yh`mW1OD;A`paMpMI5J3wle<8sS2*ya5oJ`~?pBnC)#QSx5PhVanMPY}} zH^+35^KYLBcPCKe2ec}k*=LlR*RJ%br>NoLn`hD13fCW8tg4mY?@<*9@1qciOfEjz zj-v1Z9&6(d*cj3CnikS+R^Ojootkk*mJ=LF3UuCW1FAw3Qwnu3{ha>`EnZI}_a)A) zS*|a)->pnl7y$N7h((2`LK}O=J$VLv{p(QyISgm>9%#nduLPpl-7l|l+p=L`t&&J- zMAJ$!uPvy<7+vJh7p z$oZy+)KvT21Q$l?2_{ z)-1)vqQC0P1`+AeB3$=_e)HX?K1#J+QO9XiKlSlefz!y{EF*QLj7}?gKJGO}Z)QrO zA2gfKrOtc47prku%tZ~6c7j!cYJHs1J&wE&l9dxx1H@Crx1#%C{BeV@uQe~VPY|(g zI=bgsxR*HI*|h{P_io~AjDh)#;Db0*DuQo1TR=7>)wnbpNW1|M!)pUd-8eZQM^Zys z23e~lIt#XV^BhRM7wIP#8;RZ8D=uHsKDq0%og*shq&`~UO;^u3 z1altSxq5|XV~ubxZtjrmzL0{E)dDD(;u~ua@?KJEYqW8TPz}?$0BL7BgFCA?LNVRUbiF1j08AR1z0^bw z{n%NidxJDCE#BaXm|egEj>TQCy&iP=&u)RY#qvpdLm}pONYUlqLU|}+r{Ee-EY{Zm zhb>{E@OBwsSzMDIKoY!mgZG$<7%7#5yC_ze7?04H{_@9oD$OeXA}et`qr2DW?QOYs z4-oB5nRBT`J2KJS&-`{|!0Ig`a~N)w4-!-;=uK|Z67<)Nd+nl{&Rt_2>;zcYQrsSx zt7&|Z;kvO*eIag$Gf&J9lYi6OY@?AKW{q-Y#&8NNQA{4}l2(4kaEKf2HFB;&W|OAp zzUNnJ_caR5U$>Ch{`?T!BTOa}Z-C4uhR5Z|%g5;YtnVYu7?iQ*xS-=WVjnOX^PLy< z8T{Jk@G@guAz1Y<19Z#j^dsNiW{}WU>20SKqU2y&GIs2 zoxgQ~Ybnzx=G9ckIBrSU3D&GMWLD=bICE%yR>LaC5ZAqQlvPi)CraAkM1&TORFc&F zvT?Mi6thRJm>`%F^b_0gsf+Ab&C|q{{GaXxFV(I-AGTC*NZeMUto5`zpqVov4;FTX z970(-6 zT~bmN`ppS*f`8o|*;3z?xULpM^mGG+PEt5VH^T$W?WvoT0jRXGAr;HsLL7%&p+Jiv?$Y|K z=q4)ini$K2u{&p zlH{qxeW4&0M((Fy$BvQ+x-T0lEfF%5;J zQ5)wl;Dakshun%L*VXVj5vUqhMEK26=Ny&DU8 zs+(ZwC7z%lV!4IUGo~j-srscN%mXpfwj`RH3o_-$t5n>(`lWo0+g3%lydys|oQ*Ua zZ`Gogl)6h_oUq>6tSii}an2%VOcUjf#U>4wjCSbg(aKmq%c{t2m*DNpc*h)Dt9UP- zSF~E+jlu1&a!RPW*|i?d0~4R(iHfR;(jZY!K7zPO=&e?3GUY=G*0!sbsbzTT?h%5c)zVZ z+IW5z51WjO9Ns*%_%4oLywrUG_fKfnILd3C!W2EDX?z`7FV zevexvxLyBsjHfYPxLFOB@m@kBMp2WI6~=?R;kDII$MU5W4r5 zj1brR#*$q*KEBclou5EWJwg`^%M;TUK156lLBm?rv9*<}k4Z2XFmatkQjSA+G2y{p zYo(&BE4e>Uy6o%hUNKzsU20$=PNBIGBo0%#w*wNK{Q^7`gEB9-7;E;3m_-dR27D6_ zgb>L66}^dfV_j%7`l7Y=Yoi4#M+-V!c_c$R*ru2i2Z)pwGmAyVE9q_bbBHd!q$OOZ z%bz#c$Of&;AuswN401AXCUy%s46l-6ftt4=0Z^%Mp0%MBv;VaC?#*=WB-a8(Du4W) zRp-dp2{#DFY{5WqUa4{Wh%fs}N1$%0R5F1u&S$=8amK8JMlWmLKV4hc`X|FaGXJES zBYU_IKs=-S!6QYxx5PPM)t_|;dL9Tk+u#bA!gCK4SCCVD%?GN@vBPQ1d$oIpQde4< z>>OtpoMDJM53DYBm^bk^1O|7?;=F7UjO}C+-tN)$?63=SnAw@5E>3{3Yg__DOIh5cuZSlo|^xs$iT@dGgn1mCp~7>J+fefegt&h>~hI3@t-Y9mLc_ zdr!~G+xe(C^Vs!NS-RLOSzSt{6C88@(KqsW#G2o}t4dub<@B=GbnYld@D@cLT^y1J zp3+%~*CMU!n4D+zftND@U(WDE!4u?yJnr)mK3{n=4h#HcR6fqcVYfFpD%UEe8+Ld7 zzYFfgzyN=Da*M?vn{_L!Tq$X67B?D`vjS$hB*nz+0}QIekfPuz_Ct`_a!2~?!7=rh ziRJ~{;PE{A0`ls70c?d0@;XmGM`ohf$GSBTa{9TmMx_iOnw(fQ^_4IlrP9wF{VbhI z8VRr8othLTY1(E=2pCFh4oHu5V=wcO3Y-e3=OQq(4EjW6ngxep`KXy{inTVRq6xi% z6(+QQoIEUk4vXcPRCE9TWVQ1rDYO)EYdz;SkH?qpO7{1kMWI?EfL~ZlQ!TxVV}wwU z1D|97EYJ+Cxm-I$yIngakvTOxG1(Mzw@E{QL;S+L!M?w@A4Nu$aLsMw?8=JF_(9N7 z7~YyY*M!X4SHZq2|?WB=w6l*(}(5WR9K6+G(P54Vw z4cq(eFJEhiWSrdsUepNr?s;2;ZAlGC(;Vl~KfciX>Fy3@#teU~pQvHOB)TTNAe11_ zlK|f9pqG+;8)qF#Nx8K3ekkAL6-oZH1hKlGUb|6^L6wqS(`?2}#K&@8tNWQnzXzmo zujvCcklyaH){>TS5;*{0`?xwn(FHjis~26zhpxq`FZQwjq$l+Jeu;gqTqhw>Ff2-= zu#U7Fqai@~2wu&PnAluunHSeh4RXXu60DtaMV5`N`${y!!;>M&wzh&csDL|9;|Dq_ za&f`TsMHSeGQ`XR5Ksy4;Cc6BQkNT~PT>N|3B3M?F6bOa>0njSRw=c&r?a1xKw;?b zu}II_&s;akE1j3r!LE92(4yC-5d3Y1_@c`tI%0KrM9X2rcBbXkmJI=gr7$p=CI&9@xtB-QNgd$hR#1@p;YHtN5kb@%2 zY!G_j@^_O`uJUSmkjECu*qy-J`6bA25z%e>m%qt#H-eVc|r6I@oe! zl^SphysQ3Bd_)Az_bVY{{i`yIk63Zk4@V4#_cNbwVR2+*W5I-^A$wjf6#EnzX3*Oa zi4n@vFAGInhN5fEh8}C)gPQOHCA0o}i(x4Rq|h$tYF0Fo<+Y+(IM|FPs-A7rjCwb8 zfHpm(tnYxG;PZk`^`l?&-g^FiwY<^=JO82+iKVHD5$7zyw9(?vr zU!-TYXhUND+tg&3^IjzMc(QPott=rQe*`Uj`W}z?Q!!V;+(kAvTOQU`!xXk|o`f~3 zan9w#!X$dpLI&4^KxkDoQbr^WN*Gp+gbUo`Tw&RUu?lZwPKTU0Q;|`AgnGha3@(e< z&9e`qOGhi(cRRp)uHg!i7fsxYkuUSX4Df&%(7GrLAu0d%D|Be*ozyQNS77)hT{+BkFIvIsjer z0w83b6rwN|9@;3WCT1WHYi>PjfyU54aBo%Y+#Nc&fJouj#1V&o%_Qu~e*9s*F^iaj z%UHZ+Tw4r1APYeiJyl=1s;bIIQL(elzY6XR&d~$-XqvQyjWDlFfsyz9nH6z#7xoeY zt7<>YgTFh%IkAg_%g0c8o_;<}qQ5{@b-75Wl4T#Q0RB>h+~rQ)Y6 z{u@Lp19)o1YK%5>QmWsK-mi6Z!=CGlM^m&htjZsbO)5&H*u+UVg99?xzb-otDO-ib zxcxaZ;&NJ`b?2d+Rx*0lEQ#2To}FW$0n=;42*nYjrEmkdA~CddSZ$bnOCYboJ6628 z9Q0P5ACH?}2)Y4z!u~JV#8JLfXoSuiQJRlBNO6~H zn(H8a2Tyt`KV~!Iqb5cPhurR?_&5Ns?(u}hexGeE=TAogaC;m+ptr*Krg!WJ^_sJ@ z!XJ_VYg?Qo9+z~4t?s6k0@pjx@sxDSG*IdvLOLMKMvM@sgGl11oP_61X$nB|!6p{1 zfjD(DSBwukhITbsi^;60y$^fJzc7?_#nLgA&pgA)G1-2;zGZOddA+^}wij{e6^RO zlpGJCD^&58zMl>|vpPXS)9vIa4Ji$D1V+x5EZT4S9((bd&b(SZ<1Fw%rPqppi(SOg zzc?(PL>H9v___o8{+xzxs5bq+wI9fy6fe+G^<_==)_P1FTReU<_>?@#H?#l2*Ld?e z<1)4EO>eh(+-$}V)LbW_5eHgak}dc2R`{b6CWEna@@1+ zEAHkB!HSgOxMtczsoz3CLzMzupEgIqv!oIqH^ib+aTi(ZC(v6Me6W9P4{*?iWE?>u zhUl1I8?WXkPMSnV4I>DjZD1M$1fNiN^&W(t1sUqT4!&}>_p{S593crO<+gJdg1Vd@B!Z^t>f zZeiQQ&HT5e*1j1~exWC6woJ72e3slhFBwJ>={x3i_<~z>7te=aQ^{6Knp36ma4Vlr zb;Re^>Et_pyYMYMFh5*P*>5@VgP2EUU^`esR;Co04-`fZ*4C1 zSdr0FO(vIzW)xKE;TzkmDL-z5vq{)+N~weBr$2R-FvD=cN)z&(qxChho39MXnQG?x9!%q`Pe*H zr};su_y)FSP#Q%(KQs~jqpE{$+E7h;5zcEIeb5I*3LFfV%S+lfj zb4|HWxms;c^2|2Jz!0qUFmxStyNm^cZc{g+TSiSN$cHB`B}ZD_%@xsi#5wVDK$Y}A{WY|Y{Co+rwP)&^}*h_B-B=D1;@kl0GGi< zfU(*PA^Pl38pT96p9Yw+z8qyh}*lDrA zQW}4kD<2w`t0^rcjM9&-VXAuy8J(g%7cdg9xk7k?dEuh1ZIE3&nLKyF&w1V?zi0k1 zmPw$({Np;oq6NI5y62RfzBBPjE0<1ATZ`ouHTlI|KFqvVUyO21q6VvYO4CY36duMU zwE>sk>ZcM_3n0Gs7ErMjV!f`c9vYkp{4L3%#s}6FVF$msCcn=aT!fU_g6^w)TDQ+^ z8NxvQ8QFAC^0jt5o0pGM%ig*1Ze`ZI33J%<(IBt5Z4EGlzjfl>7w0F0I}&K=&7D#p zljEqsg1>5#ksAWF*I9W*LhWjzw66Z!vZ@jR+6sQ4TPj&(Au9r4mXATs8whnix`92U znPE8MINznh>azQ(k&LNm)cFunfwQw@=Kqr=(ngBmr9DO5cBl?4rFKJfC zwD_SK`GimlOs2Sct$4*)3ue-fMJt5XUbPZ|DfcC0X6Gh=gj*1{Yjwhs&N~B{8Xr$Fi`FI|0>TOdc)Nn_STPJge!UfZ4betWRal zVTBXRsV5Q1ncWahRyrn7%Zg+JTw~a}O@jcHJ&37!tC0%dI@Y46yf07(+sYo8tX)>k zJ8sEfSVW(A_0Bf(imat$c+MRYkBP4{r8Ye&7&GY7eq> z^V)raI441~0@4zys z3hap|giSs~u;N-bgdIFIb9rcA6-LFuXUMA_I8Y#=Ea^vEt#Og}!CI8!Pbax+K@NGX z7^x6s!hQ^O2tGsyNkHA*fFQBD8g*k27u_XA%@)6Sgh;X#!>{B?^OE_^k+tTY8Zwou zHik;q4C(=Yj;sT~dNznphdBH-?M0P{tEon_L!ulslGS_?J2bjSjA12mZl5J+VU@sO z{7HVKMJ~9O72?j7Zfi=mof`;}!9goEsJ#A03;uM^vT7Bn30_4=#p%=2tRZ+@ zBm49w7@*|6OoX~l4W*KsZN!N^tAX!eLop->w>M# z-;h@Bu6!%1hBi}v1Hj2#ISh`?@GYTiT}WH|X=bZuxlkv#4$74ZBRdr1|3R4e!dEng zp)HEvJ5_+EL<#cA)vqMI^BAF5UYzo+qc1vNSpT*Xm$CPc@JV&)hx{x;kkVTi&<3yv zueHyul-~-DAdm=t3|UGoVpzAs9x?I#q^MCWe-v|=2ZifG2w=2tE?a8i7eo8S3Fd;wJ$$_)1iG0p63SHpgh_TA>9W;trGA6cg4|-DM9df_~+xAc$z}LaIyP1 zQTpT=<)Jz6)U{0aw)+xnvby-V+m=@uYES*%miEj4`<0(c((GYZA9OM0zv{vAG*`E2XqsnYKrRY)-_isrc)Uvhjbfb z99tw4!H>F`vOI=k?MWQA1xOUDW&U)t;?f?ld$VAhcfU=1YUp+c$6Nu8(8EQtqUXDh zLfmat;Ti*-&UT6fnewJ@Ez)H&j$aJ^o(RrPB~i2y(>T;))g2(+WbGkp#iaXC#uPr(OZBGH{ft7!gZ&sP^%zU@K)a(s7Dh8JMN4XVB0t9Dfyk|!lg%qGX zG4q4BQHU6$X^!8GQuxK=P;fVn?uu}W7I*^ zp+_O{!C)Qc;}PND`kLP>v}mJ_g(mLMCC}#jnrMii3^}5iWbXg#ztN{Q*{VyjZsh@E zh+7vcu{uj$PIEFpSf7w+0IHT?NfPh{jg@E>wH)g6PcHF@sdE5%%4Y0>41e4XSIFcJY#K^i>63SQJlXQ&- zr^uza6Ef`dbKCD_)cimmjvl<`{|E1*9q{U=Y#IFGJXNMH-7eC+;^-u&w)#z0^kUF6 zm8UDaYbJ>B{Gye7v~w1>u-IVFXhQ-Z>>}k|P5AlA3qivpc$7LNu0d2@GZArZQz5aV zAYp{FmzYA%4QXI}yOYGUesLSm6GhxwmFPqV<}ewV9`(;-yqwSh>{~SiDj6Ua_8Sy} zyhp@)L1_$6Ni@rMa*sGw)P>@@?hDSeualh|@bvP|Duo$yke}JySOp}T?w{C}o7f6d z>yWa_-JUeM_iwmz*zpsn%O!-~+uj$1-!*o+2F9d=^1!S~_n2m;%M>mk;9mX0w{;b+ z*u;gDF~^qAeBqCVS}DsQ&7-vGT$uhYys;|gmd>P`o$ka4?Cs;djDu+W@fT<3JqLeD z-0#vIQ2Iu#a0uI~(d2g%hBAAb+vQu~PqT6YIkzlz4z}?d?O1 zG(ri$PkBRxITDh#~(8gfA`)MyhbAFoXL4rqPQ*BRwGJK8IEd)k07*c$zp*G&jFdP(pCB=Di~9wre%+DIRA*NQd}zC@thXY( zC5HHYU6gktzNmL657wt|DUpq1Zx#CRf{>Sy5*)q3_srY@Ga?$0Ht6-*Wq=a6C0Ldm zXYAI+X&-^^A|;~a#DMuu7fa-uhUsgbi0mrDAwq;mtp`aF<8Z8UDmG8Yl0XOQKxLfM zpH2Lyqe;V0ZaM9*NffcV!5hn0HS2nvz=9l#L2ekxbUjR7pW)BK($m zLOF_y%shj;PC?0kWDm*q}6$sQp_d(NnM5qx(`_?-M z83obN_Qc7yhlmicjZh5$Fn}e>wPYL6>2 zTd+s7{VA+Z7Y;ekvH5l7uHa$Fa6ZzI{qPb4EZfR-_7dglk9n_E%l^{=P|f;~$Di0V zqKPOqKksCMllHS`Iu>VLYW`c4nCz$cerMyTIQT1HS91=iH*=A*W|!LCB1L{@@I7-P z<7O+A7-V3vSt?JHSe7)?xP20&cYZD~%R@D3A0K)dV+X-QTtnSidxGa}@SGF({$b2Y zh;)Of7tDXj#Y2=erEm2WXzZxfz*mD%u$2-AJtzR=l3_Q5WYG}JDAAN52~|h>9Z6ODB4qYp%4}_up`)^1 zn&-00z8kE+nbwykAiB4&iayQ{r~N9mNAV80j`uXqeyA||Zx;}-q`_}{lME6l9y_`z z7Shqwr`n#X$X>`8_G#x{##;ZHWC=>P9$ORom@P~H1pWpjc-uli-?_HZw<=C2lJm3* zSW@dQz9+wzuA3|aWv0oRoFR;d083ueSEp!69omX*}mEdgwf{6dt-P4`6#=bl~2p2Cz)+6e*&YU5|<1#%9hbdkv+0E|!rqb0i zyoRFURb?(|%Z$WDNw$CC!q47o4Rohu_}+0)o+F@;ZqcJ!0{{8|YN11S1M*b&6rac@ zLc!^=R$Q3N%Bp2p!3Z!@c(F_UkYME5osWGJ~x$eWFNlDBZzb_gnqz`<`k| zH^{cB!W%~!v2-qI?*vOgfm&f%f zdRyYcO$paL6I^>*f8LJE#iM2n`4~q@z}gI=50Q*dl>SR(f4!qfVm&PIJ9*pWzo8N8 z-nC{QJ##)Q-!kc84PKL&*q))8qizYoG2Q#Zdkl@@jXrErTvEMTLvgUD>*jkS%>5hB z-m}rvV9ImMz~N82gMRi-W);7lw1P|L#P_Sc$5*uPJUA!wV` znkqb-t^3dTA96{Me(V15=-Ccn4+StyiLIf5H65YauFo|xum{H-6bjM4TQe~R$yx2Tau4=YHHudpDv^y!RFY5}b&wlQ6)FLkrt`+tI!W)Lp1dJR6rM z@j^4iy}Tmt_lcMzuC8(;n);hDvtCWG=TI*(lqRzn3qatp+nr8R~c%%)zXrPg}cK9QW+!JIO&Iu z`!hVla}7xI46MBI-#v=tf zMkcrc5*1)p#XTood(Z*qrA$6#TQUokvV;JaIT^0R;fHU$ia%2sPumo%|GmLYW zLxFJl0ZI$>BwNV!Jv)f-8w_estgv_8hMrH7w9&MUof3&`8(e9-7OFQQh2d|jjx@&ASp zrQQ){WWW2VtnfpRplf?hFmZed1*-JGkpDr`bq z=%ua%#|S9JO)|s0m!fm z_d&!LIn|J@=7b<#B|iUYuUDyw2694@sg6bYC_ApvZZHIW>SV3M`Njwyc(p-qFf&2> zpKH0n^qxTiX{Mm-{%L^bgW1cH1;&KIF!rtU6@TpCzmJ&!AR5Q#CPAJk$V~p;&v)?3 zZ~dK?>JqBrErYUYgm%fcri0N}U%h{@yxC;u`Oi_486Q>znj{qFBTSE*PFX8^cA*5c zpfW;)zfisE0hjJ(7m#FKM^LV%8~Ypkxe;1HZPAB+tOd@ew-pzcxkz$Z5E}*Xe%zA2 zUNLeyX`OtEWb62QR3gS0HB`G@JNvyA{M_ktt*##P33LKu@5;F0QnA=i($o@*ez&Ua z7&ENW*TAJPFV+a$LY2_kX-$oaC&oiA;HW0|gZq)(XKJYQ>h+-%NFW2Dx7A|Ey=f+* zg1&lcF-Up-FEDC*5!T_sjXMj@j??^73YjIURCm>@TV8m9ZqIRSMyB>Lqk4tD$s`!~ ziYryS`1_C88JEP;V_FAhP^(%FB)@-GCi}#F2Vn;Gs*0Ae?Bla73KHajnac}XzkFwi zI}^%;{CrI$QQNXmJe6}L{sd0P?qv3dQa%pyC9zakTV*E}>klw=G$sqNTN_`OU`h+G z`0hPJ&wjXr+WNhS1O&EKDG4k5B<_&5)#9_xN~2~G&~Bp@*W~c|*VB_Uf3jA`Yzs`S z=kT>HS9lOV2xWMu?=+1_`Ej)}0Mxjg4G}fMl0$@d{*>Tmzsdi5#)zr(`#0Ub>q!6K`GPB?s8)j9cS#h&xRq@x3(5=wYrH8!Lt=%Q*WN z3Lb0ML1PO_r7go4nDn>_n;OPt0s`zRm*K9A@`sDQaFiWsv2=GI!c7RJNX+(oLPX&# z-~AOWb0{afT-L(!LxcRHs3ILF0g2X#x>N36*G-6hUx_BCxm^07;}HA^qJ?V{B4H50 z3uFWXAUrY(Ao@wmrY$*Y@o1zU9F+qvkx304>L~1YQP}XdqrqoflE9$YYaCudHwYD? z_EvTtvm579IQ75G5ti|~A7ox(GDhHy5x=J&TP#O3?dV%qnJ;7%T1=uq2rPLSoVkM* zsJZ|$lL63qA8LL0jeE_ZBTo)TQ@r<6ASk#Q{DLcGrqoy%JE-hhBN&0yhZwhpS(YSh zLg#92g37ojtanVZ3Y<(v^a>npVQxObF_C~FX5I`NYeMctYEGSk|MQGoB4c0kND3we zowAyUm?|*UUrPia=IQK-Mu#)acP8=zc5&Bqh38hA?>!ATmh}jpR;KI)b)ls5Z+7|> zZ*V9rBPxGASKWNe(JSgg!#^pY*wkBC#iBV9=B#DqJLx!xT9!7|@ ztnyNC{NIJB6USC}^I9G0RA4;l=#UY}L{%v-j~Q#far3&wu*EMR1mbXj31?paOtK3# zTER#^Rot!)9^2t`vMemFK>r5lBF|46K?Z-;ewEz3wva zZo;8Jqq0ZqjhZ8zoxrCF`Z|H`dzqTvB-LENit#u#TceBAzSTQ;m9i&!)_$N=3Z`XM z4QyZx!leUzLtri6vr$MQU<6+_o~f?Lx2By;qo5^$K&fBt+=CddB>HGO-0UV$yAma? zC92|eK=dMYP0%LyKaf?f7w&BFE*OSK6ICOpKs&pnD@vKEBN7`-suStslZ6K|OhF%| zwrn2%DR%Lu8}cHwFH5}y>`eMfz3EHYSzF&-9FDflk29XLbsgMr*a^KJ2Csp~>=n!U zj{ZnM@9ff6w^bx@tbd$4+(b1tjnDJ)Z(74!VF$149x5g(bt_bcuM@6h{~olTFuH#e z`52=&*t#}~cDvocJ@!@O$hET$*IQpz9u-6`(NP1$3n>XbMFwN?RzQv&j|~AT`0quk zFa@$q?|5<4*t(ihbh?1kf6I@>>DcFZKRV=i4&T0j>>kwcLNjcv6Gu&1qpIWqs`He0 zgOHpxxtU4{>dc|kX<$}^9&GG z;@Flqcqi*pQA83lOLC{t8}Azbfxk#8jbFewV0Xwl^rn179v-{oHFVRWoNjmMix_LI%vw&e$KT4!V3^&SIresj%0lTQ|lyh zm%eW5PZt<3ry0`Uhy{x4+a+n-Kr2gPAeCNunz^1y!fOxyp5zn_;zf5lF0#z1bf z+=L-B_iL7Z*_R$64T@Fc&}4k*)f>%m#w6>!KDAI{f$q_Q$4%5x+X6OEG1w3v%$v$O z5U(BGjKK?n)Nm~)Ka_O67O#{8qD(d;lGw8H5_@(zr#K}4UZnH4On2f3MF~x+ZKaCI z((;>ouMN1(P9*lvo3aWXUrk%&Af`P|gH3fkmpIc?RW?At+^a9VKRBkKI+TX~=BBWZ z=|Vp9bwG|MG*1-B1*ncrV+@PabUAa{0BPd4X&O^QwV17cy|He7gu#U@=M(*+;)FkQ zQM8$+00xiRMF#uF`4R3vM-=2O9Vy+F7fXTYG5DKyuB;6c>%MKya3NMTTp!wmU5r5+ zVPqKFibzI04?Ul{fRBx~VDmIUmbQ5rVK9pk@i@>Qa_=<=FFAM)UkQTuEdotqpyJ*D z#5YU|qAz>YVUuOtr}^UQ`5<2<`8)UGrFmslAEl1ddl*!h_Igr2*pl~s7fP%o>MF$h zaL{_NT~AjQAdd3uT*qMYwDD=jV8lcV3n%sfn$8qGaqcr;?Ptx03)wG<7cwmwQHbw@ z<<+Bw9P=F9SNgjDVBZg~48=f;c=;yk(XF7B2NS{SC2h%U+QLw2YVuA$WlxQ5>OT?U z%X;G7>?bD)p21f)xf{?HtEELoEpN6WvBm&Bw6}+~rrrfGoNnHCO+SLAI%I}Q! zcA_;bk6;MdU+Bnw-g-ECR#e-V7>8Sm%;Z;fM4?9@=gy%fmHKQ8-oXuE5^X^sOi4PPk(<&;NPFL1z{hj z5egCJ+*owhKuMsy6-k(t;A}^G7=NXI1er7K3MS;POTuAT0lsYi2S}-jhf%H@6_qI% z*8nwj)?Go}#!e*Ck$MiE4?!T0aOn=&rC7~71-PBB|Npop&UR%5{pWHGghybnCs=ZS zK!k}LccLW4+#m+YI~eV~h&7^C@{xSHEIbHWQ-@92^wL)g!`pIX+Ql>*H8$~&pG>ye zsmF+o*vL#rKqvdt-q(QzMb1ScBw1Mbs{@G~qsPR;ryF|Q?leA|A*qs**nh`k!CNi)FQQ2J zp4T7F&)YYIYK*%kjWHi9v9`RpcYVkWvb_y~%f8el$eAD~6;6L>Cpu)0 z?IWSMb^cE69s{F4reg6zJ)ow};k3ygLJx*ET-RoUVR{9+e>=@hEZB#*g~4n2i}1u= z+|n@(zIOd;;8g;rx<6IEtlQjARtj!y*|0mNNyy2ee%%C9(K>JL%@qOs#9jYmD@GPWYauq7vZVN^=|zz_M7h!Cp$d9zEr$%|8_uC6nWsntQ*sB>Us z1~HP+Um}nfgwoew20_J8i|3z|8YrLm{`VV4J7DnzIQQ-0TlCwt=>0CZj*3y7@qk$W z&jr30C5nehDK9iY*2PLEVTn4^3Y2GpS?G!Q)`fSSSGlZ*6uNwV`H4$SncF|`SdOGl_s^)j)(a~$R zhvA!RM*4_>^4aX`KG+r%l`6UnnDoQ)oJ&SB$ejCJjaV^)u|X>M4`|gh6E>8MR;?jr zsj)j(xmLAYQ5F2!2~_z+Jm*dAckK#bddg<5j$aqg8`kd<}MeKw3#e z`4EcudO$x#5Lw1aWLaxn$wLCqp`&IT2U49C2>fwQEJNbIH?hbbrxq>ZL#**@F|RbM ze#M{}SsuYKxv$>Wc+b58na6RQ21Bwr>8%@my{Km2O`;v7S%cJc34T&DVX?6;!zqBi zKEU?D<)z?sMQC6c!LpPg?nB<~z_-B#4kB)s2GYasc?V+>g*kl0C8sRw-+Mw)xNi1n zlh@yC#%Du@=iLT1GGTQQlVf~{oIyONRO?ak1?G^KXDko?y^|45;Q|ZjS+lb4GwAxFC|YExwyP=muTj3 za7?k0K)@EkJz{Eq+8MIJuAPtJaFWMh-Q!5iT1=tI1NLn=L=7tQR$k22GifRP9ugdg7Q2zMk;MuKjf&jfc5=fUiH|`7jt}m4E;}B|-he);`XE4d1!ouPzSm~~B+ffh6zoH% zk6p*4> zvC|tzS~nm!P*0z)H|f6=CK$@*8-NiHTp!jk&2PzY#$%-OCWuUkOl^<}MFLU*{v&|P zw@@BgbcGPymSR`PL;0v!^d>fFMrq*I7JpJtRR`Kc*>@1NTKTJTchCKSb)7~R3z>ppO)G|`d9k3loM&fzl_AUy&Q$9B%OmdGyl|gPc zmzPE#|03>T4!zguo@%OtU3P{sq6+)U`unNsUWNxQ{*tB!QA&lUMEwRkd0=f(-%{2S zQrOj~*h?_=<4c$AaT#-38At;3K*iMg3Sa)Vfqq!;{-N5=cz)O6P_TwOcTvC~UX}z_ zLbP8_z~I@N+2a39IPZ$)B0*}JY%aZOy|s;b-;)VP9viV5<)|Q=bhzmjE?vzq4_tn( zY$^U9@&sAGuyC{Z5qJn@S4>-eA?LhDnQefVV1uVv?iYeA5Rw{-<%F2g@Oan-L^yvr zl-{KI-tlJFElW60EtNgCz(+|J>YY5jOqa2Z8@1rUBZI;?p+-6Q=3ChMv>fNNG;p3E z$B(AxI^XgKZrG&S3YCAtFgM8Q6t3@|$9km^mca&jc{w*sUisTDU$iY588jR>QWXzp zm=SKJ&J*fO-(<=FJxPSZKj3Kp+bAUg{geN3%<-TkGKpLVwwUjmVR`E%D4oMct7qb( zyHwORFa)NGZQb&&Od$N&E@~SB=oA3- zDlw?bl%2BIwvkHRO>~qHiC@awEoTV~o6^PsqV0O*7|)+}Mi~N4)E1`262T^6zWTh7 zwiS|m)ZOF0zh}z>Qr^H>yD5lXrENwteLT|7w~e5jP@W|wT45W)TC$yLq72IWTjihu zON|BXTL5(aNG}n!I6Vh&lU#y>eof>d&ji%ed7YNgyA9w4y9B4<^ymC|7o6n@6pUdAg!@^RKimh~ zRI2L(8)!UO!4bm>OHy#yi{zbCriZ#6aV54_L_?9!w&=l9zCv*a(1FhDNs`m4LpK;A z@2E)CFt;?TF_w$zkP?y*>Jiu(wLLGio(=$VYX+Ur!Bh>ERE78VAMBQ7rkRim$?ri{ z9X{^p9Ns_ba7s}eRQYMNpK2Q6lgHdl%%!_pB0~yWdaD1mwk#+LZWMHH3d9p|731ZI z0C2SK_ii);!e?m0KC-RpoRRbvr~w{M(b!g6m&G9V;BH@$CP%75gSNhuL_?MRab>yD zM~7IC45^Uf=ZOrW#Exyu82c9L?_}o+ql?pi+{SDrYPCrBAG^*Ltyn~O)?y09MSOUH zFPegxACeVrOGIJ@lDkb2Gb51}kolQQ55f}nJYH)R=)(0OFpdrqUGD@@gsH6=?7AdBRMXf#igAcb>Y~;2$k3&xXpmWi zjJOgxWxTH4Bs$@RN9ZOC)NT~963MhFM0=d7psuUO@1cD`^9`mdIYT#(>CKdCc4M0b zD-rj4@qzdhfoO^LqZdEy&jj-);BLY@c^2{2`C`L2DaN??TOeWwa#mY%GNb;$y^%YCaE(w0L&{K zOAAv~E0^}QXG{}6VF-%J@h5afsNsdxyxTT=^#SXIq^!*|t3pfB(DqX`d@D)%#T?!7 z=vBnBs7ne$uNcqj90+*^$R>%`;$IMq@3|>J5QBS)p6fr?se*%Gz=SO)IA}(3IcI=I zj%efaDrugyD|8oIJj5Co1qgCrYm$!(D*%!90+R{aWuswDaDb`Ztl-tni<~mRJxRduUWH zMT&ka#(4V-`YvQ&+Zp+vgbvbu`{Mw(%0A-6TA-3}x0w#jHRZ+kp|3`3O3u`oa9<`O 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

2qTTyLa?<35M8)!_+~SpOfgWNaTe>JY z6z}w|3`?Bu_U|~UBl7oVC)6?>aJ`;DVyhtP6LEe&F0IN`SpkHq757R-MMb7{mpwCZrCPG1I#tFdz>Y4 z8huxXS@az=%0_`s7I$gAb>0o}E25aZoqwcE+_j8z7!nbZuAG`1&Rf=_EQAA|qxIQ$ zYs-8{$X-RgtaJa|}A6~m@k{Zi(F*q2FfLmj*KU$@GLR^{aLL;PmqzaKDR0`-OH|$`d z_i_tnq4B`(tz01VxP0rSeoY_<<`K9xfT(+=9LELV;diWfhu8KI`~Awg3=JBxAL^lY z+Ta!+=UCVuUrwOiyWsL)2sDfviC!q+D95$~T0<**Fc52zC@DyAcIWu=x#{pBItzP* z3Dr}!i$|p0#zfXY-3AK5{SK zJxO+U|B7*ur8X**2d5X|)*qUMQBiu`SH2B>U5c%#K44XarCJss63gorqUFbpFQk1w z5Y_w8Q2|I+2K__$MiS7uA%Ln3@?fB#MnhDISUKv3N{-)}+$}9_){gQxPI%m|#s;)l zudOo;5rSrlh5cPqF?3d8;2TAgbK%FsVtEXdF8LWu#x9b7NiKuvpDbLOf)8ZCV z-wGt(#X|BJ(^1QNVd7wK_JM?^V^EdyyF_ge1b9|b@rUwp+=Xg~k8(K;khG-+lg?+4+|n&{=dx za;jVTzKMnLkSgtJSS@&Pj;2h-a4r6zZK|jv4HmO~W!FD1hb?eGt zn!yTq7o;g)?ORf9JFzbGR{YpAy@QUPSs0n(pS0hEf?MoBzJ32&aRqq)32S-NtD`gse%qsT&eMiwp zPh%PFB8WvodNUkZ*gIhmi$YKfwcDmXj&z)m;6aPCt>=r_jK}1`j)pRbnDLX?1nFFE zbwq%9OEIAJ6ObOdMbRdFS-HG?b9V~f3Psx%eAw-3Vvl2MYp@R7sD2V3PK?^d_Sgt= z$TQ-YWm@D*vIe$9BewBMz+hHGFH(bXbPZp53dGaftBW*UA5Q7Y;e0e(!zm1)CRfOV zS*h%Aqvj&GC#zc0-#v0TVefFG!@j!eg_|T2|6mZ?Vq+t#7G$tE0!tKoj9H>QiZPTw zl8l!U%1$!NC%~8mq*#G)kHheX3NcGbEOWpWoCRQxUSu?7K8B{@3=b44f=MByyR>l} z#Fqtbv8`|_MsMK9n_*Q6W4t^oH5fS@e=C|D9E;B)lW6y&H}RfsuDpOf=}eUOYP)(gV83x0# zGqx3?{ibSjg?Z;lmqjrzh{{6)Bht;x;HfkH=R?!uhpaQd-gsWq*XM*;F|XtQi(TaI zCog%-5S|m1v0IPPZr*qoS=F!>-KeMJ6u91^q1f`;Dw-Uc(8K86} zGv%L_PV}%@TzKIS!u{?`C#rpndPN7T2FH-3p19>DJa2z@qUzehfaK7r?W2qKGpV=D zT8!$VezV{LB(#|WrIgSb0W-e5*YGrLcKx3j@;>qC+tPM48z1Eboi3;wdDNy$zOkhc z@&Bf|(#Xzf<94U@ne}5F`E5kmlC!Vv4W%0Ei6~#t$DC6USGb$N`rJ$=1xF`PqE5w} zOKFPW1onG66OcUb0X$@9dz#H%=@6}Zn>`^5#(q5~$tc+2TQb2v4_+2b5`^>)Uc4Et57}t6LZ>{U{3 zuOJ`0j$a0JdDhNbH~tP{Z(yXRp_&Q7pSw7er@3efl8uw8eM3N;saWy}a+l%WBCnpw zna0T&S~>AQ9Y$XfRNO=WTVnM_hhz3fY;uPahH)ANG1$3AT2If@hG~ZADegG<>*sja zROf7)(YD!r?PuvHto`<*N1z?3_5s$8#rRrjeC6=x>B|v+^~&FUk9gB$U*zF=roYhY zD>Ka}`YgJ<%n?K6e#uY#sqFkI z9;s3e0Wh?E=Py8m#ga zeV^Y&yhZ*=Vj)f+jlxq8br$Sq@{JmD%b2q;jFN|?Cudf+RRI1b zk(Q6EAOq31U0eFZdEUA9!bQJXdOR3N!45h`)HwOjr6bprI}Pj2A= zTd^)QEiRC5UWslh+skm2x$nN5+A>gO;!hDwF2SFTdOzgomfsoshTMh`k+_rHC2rO~JDX{=rXJwOEV!b2!7P*`tHOrKvs~0JS62lMboDFHim~K%CBJIDhf8MogT4 zK|;Nqh%yRw$VQZlVwj7cU5D6~Mo9X$F{)tLQ$rsZZF&K)-K%AYrdM_EavOzb$B2~h z&0~QPK$BHWeUeXrs%R_N+uyT{oW~Jy4x11EAFQ*~GF-l`yyC(06~cyqpraFBk^2p~w+k6|Yo9K|&Z#K*w#mIXzs)Hf?DzD?@!vgtbJv(6ElGez>RZw! z?q{*|1?VW*I56-!4>awlVcpb8P^wten6c{4GXzcfE6KOVbBonC@K(h&U>NUCS|mCI z`B0H(CtdoQ#$Hv133V3dSD#owDxHuJkIXH#|Ei(JJGw5ngUoiV z+>xP*g9W#D_!9RU`4$`80K``bep;FxLh@P#0DDuKwnX%2>KIq{@cNTnb$HfGbT!xx zI==lLBjKjPLS0_`iy-Y|sn-z;6)}pU;>v@V{h7iiu)Re$oTt?YGK2`+GaCb{Wom$S zJeJ}9-p##2p_1TZOagS><@f({Hf1Ft|F+yb^gfVq?s#tRo_X~C#+*{Yv^k2sC@c4x z(B3;XwX>`tOnWn*lm z706%XG6Bg|LR{&nhuEu9ak~X2Bv&cXSJu?s88zqb^xpy@K1~j{j3J)6mWSy%01=jQ z_JCvK&-*8pJ(8mhlw_i)7=ptDd~8$ zAMWeJU$9sM$^U`gjsKJVar}*{o|ul_{!J!;Y^JlM04p+h$^Xuc#|;r~Mmfs$IIHh< zBnwA?S;+m7g*dtm(akUW(s|gRYJx29ccdt|(g%lrJAYiT2X|L-MhjF5j69_&4ONCe z-;?7`8mBIEmJNbuc@*`Jp4SOoD#kulfanf=V`L1jou>|B=654se`UHC@w!&xb98Am ze8g#G0=>4#6f3CAVM<$OZoikVtaRu&+c#Wz^g5zXTB+J7xJ+(wK&H<5qTUFwJO z57+7KT!lq%Zi9|VMs1aSyYtS~7HRv>3{GK+mf9%H}wTOuYf{1tKM+ldrzhAD!(M5m{iTghP*m5!(g~gisx?Dp3 z@0mtGza@k78IK8RPuGdrX!DxZTs#-2g&{zxSk%j4g8S%L9dTB%fLmnHDrdhlV80{a zdYSd307a9KI|(g4HacwZ&@?H1Ryo(dqS*dim7vf(=TXDN0RWlL`5`d57i#=?WzDNZ`GcM&3j%RBW6<`xWEp z5l(Dym6A-$cNWu)W~D3cLWvux2TA!!rsYn4$b6p7gVWu7KBlPr|HMcKRbH9*oYKE{ zj}*~7gY$-Rh{6i!w_HD@qfXy`H7Royql9PQR_6U0LUgP+j|;@cMjm7VQ{PTAoS(P~^^Nxd zoql@1*Yg=}uGQ;2wT7UXM{Hct@e*Jk-cJ|=63}-?W~gSg<^t_Wr}R&Xl~SQa)S7Fo z>nL^eXGYLIb`8o1I}|bRk`^$zt=@eL?=BEQdwSPpuBE)`AgQSU0%)N3?qS-FuO|vr zqq}A$67)TzUG0To*or00b=H7*F2bngEAkla_#q8=$z>HF*i3a7u@A)|G4~}&(#UQ6 zo@LO}o!sY%xcff1=?NOPZK-kEcARB?+?fc1zNtDDAX*(9PwqP)1;Wog=q%5EPEj%I zS#^lwOP8M_O7)^>_yX~=-}HHx6swzoD&Y5OO#mt zNu!%CMERa}s4tKsa&*i|ldHx0+)4&%7iMFZyCS>S7&+==!t1mv&G8GCA=Z2>nd z)>p?kEV%gYZ(>ziBhgP)-$UgOFr#iTzG&eMx>(1b4{s>I;oxM=&@O{tDKw>21+y3^P5;AcUo~F!ijDZa~ns>`^9QlA^ayeq-XsiyDONpG^!Su zjA~RwPoVaeZNqv1i|ZM#yd-Th$9<2tpr2WWFqkwP005U{zf?-oS#%7WMZvh~r~XOD zr9Hg^DkQy;2h3YmwA<3a9J76(FIZLYJ9}2G2{HX&C~aHp*@G0j=3aJohlQdQfZkf10-5&a`Y$r zy!4uTa)+$16>iDh!#5&@3WHc|F)t5AYJ@*(AR=4d5?iCIBG?|Sf2BTJ(#F{#CNtJy zAW&VE#~6m@YET-K@SLM|E``vUEew(VGf}NzJo4GaJSTx3LKo|kV{3$W$=d!NZ(m(L zM3nem*$3;h#!bttRBJY<8wx8T;|RU+shc++pA|V#l{pgeNduWT6^?{NnQsD4AD+rs za4jee&Rk?!e03m=TcR6%kgg7ec$<&>k{3D&95GgD*OkXG5$x4+-IVC@h}nzm=4dOS zjXijgeH@$H;7VA84$n6J1|CA>$%TUNMrQFgQ4%CJ{TIp+yM(A=@73Ga%jy|K>)!VU z#D1_r)0I6ztWZ%~$q|rc+JN(mK*-`jJH9w#F8wNWmz(I?2UV(foF_zV$XLC}Agko4ZmP*t|;Z|kq!kV&b+4~86H*`;1n(-yff>j)Fu$MDr*askfS-^L2( zX!w7Eg=IvBBe$qvc*S6;{kvmxRHC>1Y5X|)_$mJzsHTMWjxT3xX6KWONd3GmuGu#0Ld^=ol!Bh&l; z0>laI|Esf$Sr!`Js_uO+!AK5uWOynW@4tdAETt5CpV!W}{|%>!jzxfJB$uHCpn}Gw zIx**US`Vc2EKFnLH)E}s!JB!3C9H!|2C1vT2%ipf)j}CGxtHzk$Xs($0GgF{5%a}DxpX@oJ@`DgJSR03XjXfPn7{_P$(>u+9ZGpHe6m7P zZzySbTy!ndg^}-ST1`-EcZAnM5(^NQ1*eW}ts*&;7TNQxgzB}U6$)u&(xhvhqryF& zV>bi>+IN2gP94q-#mhiB9{6)IZpn%#?)j7#G`e6`1ClhEAl#_7k<|s~b+lXP-QniR zb{EAJ9yU1f7^*VIUT3a7R86faUFW%+;+oy8o_r_2h>lqA1IK&MDi>1;)8EC#Q>p{3 zE&ENf&ed$Ws1S-^)i!&?%#0%Oa(jcxvzV-T2mJHee#Ik+pYebl7mRxvWQt5ovud`H zicsBjMJWoKYO^`U6^N@t?NCIfMYZj~hU%a%7z?)ZZ>fAUcRPcYqJI>gIQaic5^G<2 z6wD?U79}1A`bVB&?^)n{o%UJfudCrTdKtx+C@Oz4!K=?3q`@mB{wGwLB$^~$mOWIP zNCtN5)-Z=OS;bZ%9Quabq9;Sf>^@9GQ-sx$o|&ZxPV{bdE27vg_THOUJ~NhzGvmNJ zkKiSc-6vzT>mGxR>G7^V#;~00FCo88Gyb5O-v0-$59sK{fuM{xl9*oUEuA3Y-}e_ z&QO9mVQcRl^8|t0Elu`=R}gVB?MxzG(7X}B#Hcc%ap`zagf|bP4jDFY=3l{2X9!Q` zdDTIs4QwnZ)h=qr3ml*>>gVs6J@SN0N!isX9^OR^!GT<}xFb5J& zR>+(TBSuPZa!xGMS)1(1XeWqOY1!4>D^METJqEYOQRt*(sA7c@S2~0cGyW5Gj?pJ> zjBq<%q|+CSvO4BsEly2}YoCO$QWU>-uUa>Qgr=`ZX*A0yiOaF1P}a}vCHTl(e%F8O zMsS~;6i89@7Xc1ltzQ~-w12?R$iEUM2?$|fYVEbJlZIemyl8iHH4R|~v|X=V9#f{) zIhjaFO8gPsRI^8Z87o;)j%A=II63vWJwOhfoOGWwv4CLAL9Dmpk1MMd^*O&gd)ltt zRYpX$Eu#pHV4w5+D4J5&MA7}wwdGBisRu8jHUTpC_$dM901Ou4fL;MuLmiaX|($0~EW0omt&a7BU=6} zz(M{F%i%q`Z5o$sKf8t=jd+^i+fz^f<0T`n%PaFPMlwy0wkyWX1hhGZw*-^$VdjXf zNo=eL-8|>;++G8aUX@upfQu}F$=%krNf>8-v3lWjmn!vSsCHvX0EjMB=7vv0{&Tnrf+OldF-oMwus+7Fs^ z&P4RZs8t=3h~nq{$u844STFKx$+`JNqwyry!q?yO#mF{$TfuKG!^djMH*(9_DNqZz zz6O&Cn{X&p6zHZvP?QtXIacK@POz&P`D3@K_-E*E%Q;L5Mok050);k5H$(Y(p&a9u zfql1~?#a6l9IIV@;P%xZ71Zp0uktzU2uoFe*t*x2aLKO`d!7#w-SG~~kZ5!$S_OI? zOK9Ywqf<)LHsXgO=$&jU7F)s`O)hcw&Go)e;|9E44`C05BnT}MT5h3(lq6K{hUl4a zPIZqn*bZQQx4_G6Pzbqw#qITOAO$bZK9VGc&F%q}Ys8D#1_aft3HEd7NoOBCe($eB zJ`h6ecx3gKb0)}{rBOkuDWeaH+1^j^5>O%WT&5OBtaXUo_jT3=hzbXZ{M_IVw1 zD8&FabE#COqYzV(_n5j)H(rW*+3|!ctjK@?hqf*;TiCF<*Wm7#99wiY-z3erqVF6J z$n`GS&{-Ziy6$2!kVLabfCz&k3RH-j0xWnsg;*>v+RPeudXn}SOb2UyJUE8Qn2v3O zP4QA%^>>~GfuW)b2qA&9+NzX1@ncsHn?$60A+_gzxA1&;XEE1gIcr#l#0czQQ;z!% zw_$n7op};x%c^L}O|_h~2leamI#-5)q{fyiVkJseS1365(fQ4DQ%bTqupt-4q4Ym7 zj#a1GTO8-2;f|vVafnsEmy*;_zuXPF9X!pfJ)#fB^mMbbwg7hh2NGxwdAphom%FXavsQJ%T0GOIrwN6I%yiJJdmO-C1CPBd%3or!}9xQ(WD103hj-pU6$T{pB2`jUrzI= z_Ojhr2&4KY+dNQ-Ftl2%hV)D-IT4yu#e83{srOZ4(+uK$YB$T1yO2PghWK%YM2n~X z(Px}?i41^$b_ccJ%hecCO}fOTnSvH)=Y@s>FGuwH#8!mBf7J&V;`c8KPE)(F6r%uz zuU_zlZ*0iLpTnAVCOpaZ`X4qzS?we1opJu78jZ>x;o|phl!VnKV!dGLu4`P(zovM| zB3`w87%EN2{t5LVRKJ$YkWmCzk_L97ms(`X2O5Bw6?9^*=IOL331v>>3jRl30=V{e zc}hKZa#qmVC}V&cRBb1L*3D|W50vdwmy1?ql!Mm*srcpH{2H}!y?qyT0Ds`o zw1C$hVn6Wrh`RMt&0evLC`FF!!T1*Xe5$!hQXy*l15fw zKlJSHD$Oq&VVlzvuCjvUR3PsV3dnDzbhG0g+%NE*+54uNS}&=>v*jHJuvhPH0x|{R zLwNw^7lGU^?$>grrk&j{{v zmqK$WBEwzAJXX2LNQ{5ZZ?T`^6WlDg#cw-ND}wB*$iaHVn>{E&UVVf^<(|IVx}g{6 ztBUa#g5TqR_0L~^4g+fQdRCg4?3&oRI|`5Y46Fqo`L?~UYlCFXD+=uG_$h>CsIx48 z*9~YF zYnBm7cilEjL_WBIHLE+Q&J#)+8B#Z@H0yi76S% z^=@8!Jh$y-+b{%9bg%d@-*d{aKrjv;X+)V7Ja3G{_x3KjH5=)!Iq%oh8?*|y!I)P> zqbw@fO?bMQKwe)sFQUAgeOLr}0hO&+Z36YqdT#t&wFVq{I0no0GSH;HRhCTbaUUXc z5H!d~5~_22F6ij;LLO9|pKQBBj^j&`heTK>*&PI_Uh!grC!`Z91>yLei9i23&S9RA z+drn6hYK} z`ZNL2{)Q||j$2xIC??n$`gv|2(=NCb*(P>SYJ|kBtS^u$Ug2+Axv5}zPxU-sn$q#8 z@prIr;9_l}T?5z$n1@svw}VDU0EbA~ZMtSC(Ow1cP3#1Ot&bGg8K1a0;7HSB1?C>T zdh7JN#|)v(=w}+Qc_zVfW!u7Iu>x8t&bS-CE#V{OVOmJ-Z$Cg4#*jV}_o{-IeL+R% zO2tG%eHzI~Btb^3B$L2f76&!gA>5$Yo$g;c0tWHc+j446n8|L@` zO@?Mtiak3w_+y4$m`@(j<&#jx{h6+2e?aP(Z$i3~4iHUzZ8E4Ae*i*5nakPiVg{E| z8WGPEq5T|wCq`mi3$q2) z=$s>V_!c((kSlawp}th%baUvcN44~N4}Q4Oekn4Nz^rTg0f&|5U&ad z;xE3xL0NLO@V4&TgP9B@{denAAXynBf`SE=l*qyt+=3wz^V%m7w^^G!lCt=1>XWc0 zL7o=Bc4pV-no573oYWdS<2&887JymhrI_%WW&esuDVNW1d0cm5iW`(ZdT?+ZBGs9= zkL3J*dm__*1Z~*;GuJyWfGnxGnXHl!$JvbayGg6-a~%rVL)C6UYhu^e_ij!Cjpv6s zA;C6Ytes8b%*~1{&41dADWD4YSjgWp^z z57zH6HVK_6)w=?Ui^GNCqp=QA)Xv`0<1~5@kXRHLMB}9_I9Kv{ZJ=H4K9WWzB|X!L zGsICh8PmP5496zh3ND#qULDq<3mx^&eP+La__3WoCG)xj?!LbhUeweu$`s-)E~1Q% zrb?s0q7o|9e-&~NhhEhMc_+5m>THNWJx z29vL&!AJUE@>tK3Mfw_2fv=H`e`&7^68n5HX?24KaG-lqVR9ke+G|pSj8-1`V=m;z zf@b~6{)xsv7!*yNSKg6lX)|4gfZ!bp`*|)adV_V=-;}!!+$rYf@sPzPmO3Ah_7oAj zaRgE5hS$p(il8<_?fOb%%1Uw$YFJ8(Qf)zSi*|_st2y+8XlDUxgP790uQHv6S{`x^~l(erdlXxV)6SpvBea?sd<2S8XfmpzYC-K)o>hTX1(Q^2g( zK>tt+85@mWzK7Lg{>QbWG#fVz*TG7gS4f8zpF=p_fb{x>u&XwZQ85`Z6+IG%pUeNh z+C`UeWb+}lxA=9X-?yQqGT!QGtmzU-7yaJuBjC0ch^3%hryd{AT;Gk_UL+jR>ydE? zki}!J+!qn<_ZVCfzJYg$&uoS_-NDZY63e?6Ss1XLd)bTN1+krm+0;jp^`qaBZJ?U0 zc@bYChC97Vs#65jZ22ohb=B5V^jfNfpsg!ivcCJDr9+*NM@;vvErU8C*GX};V|EKO;V-AH%dN$e*6?n6PIq~ybK}M z936PuXFdO7D?JKGp2G-$R^62F5FJX_1n!9n9j3`vrfX?WhU$Ar@)uWIn6^h(3CR}ur$UYOGJ%4Yjg;bt>|N#q6Qqh0($lqMz&Z5O4FDE|i?LLMX>ghb;QhCTyV>F6X(xJg6yxa? z4BJB(O%Z7;{pP`F;{&Ip?(7AfLA#-_AAzE8HIg343L)BG9m;Q4E|A`CyULUro!`!j zLzTejC2dNbo9E>J{}BXkakw=fl6!B;gr>O8hS;2f z^}$D~`o3&4H(nW>hW$n*(lBvg4?I6T-hg+7^NK29RT@T+;Ue;mutAt4`GA&6oAGnj z5_WQFRauMN?l2WYa&hPuAdX}~M@l=n6!x`c5)tm;EhlpqG|$m^NI!sEI_<4Uba*^N zAy*>ciT@=t=TGY�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 z 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 xZ81!@uP7;N2EAcbo`+S}z#BUmh4 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≶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,aXM>zA6% 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 z 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 z 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�D4;}9$1Q2$y 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