mirrors/gbe_fork
1
0
Fork 0
mirror of https://github.com/Detanup01/gbe_fork.git synced 2025-08-08 16:45:34 +02:00
Code Activity

Merge pull request #275 from NicknineTheEagle/nn/gitattr

Browse source 
Added .gitattributes
This commit is contained in:
Detanup01 2025-07-10 15:16:10 +02:00 • committed by GitHub
commit f25f765c2c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
74 changed files with 20757 additions and 20760 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
.gitattributes vendored Normal file
View file

@ -0,0 +1,8 @@
* text=auto eol=lf
*.rc text eol=crlf
*.sh text eol=lf
*.bat text eol=crlf
*.vcxproj text eol=crlf
*.vcxproj.filters text eol=crlf
*.sln text eol=crlf

5114
CREDITS.md
View file

File diff suppressed because it is too large Load diff

11
README.md
View file

@ -54,17 +54,6 @@ You can also find instructions here in [README.release.md](./post_build/README.r
## One time setup ## One time setup
### **Cloning the repo** ### **Cloning the repo**
Disable automatic CRLF handling:
*Locally*
```shell
git config --local core.autocrlf false
```
*Or globally/system wide*
```shell
git config --system core.autocrlf false
git config --global core.autocrlf false
```
Clone the repo and its submodules **recursively** Clone the repo and its submodules **recursively**
```shell ```shell
git clone --recurse-submodules -j8 https://github.com/Detanup01/gbe_fork.git git clone --recurse-submodules -j8 https://github.com/Detanup01/gbe_fork.git

2712
dev.notes/interfaces.csv
View file

File diff suppressed because it is too large Load diff

116
dll/dll/ugc_remote_storage_bridge.h
View file

@ -1,58 +1,58 @@
/* Copyright (C) 2019 Mr Goldberg /* Copyright (C) 2019 Mr Goldberg
This file is part of the Goldberg Emulator This file is part of the Goldberg Emulator
The Goldberg Emulator is free software; you can redistribute it and/or The Goldberg Emulator is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version. version 3 of the License, or (at your option) any later version.
The Goldberg Emulator is distributed in the hope that it will be useful, The Goldberg Emulator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with the Goldberg Emulator; if not, see License along with the Goldberg Emulator; if not, see
<http://www.gnu.org/licenses/>. */ <http://www.gnu.org/licenses/>. */
#ifndef __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__ #ifndef __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__
#define __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__ #define __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__
#include "base.h" #include "base.h"
class Ugc_Remote_Storage_Bridge class Ugc_Remote_Storage_Bridge
{ {
public: public:
struct QueryInfo { struct QueryInfo {
PublishedFileId_t mod_id{}; // mod id PublishedFileId_t mod_id{}; // mod id
bool is_primary_file{}; // was this query for the primary mod file or preview file bool is_primary_file{}; // was this query for the primary mod file or preview file
}; };
private: private:
class Settings *settings{}; class Settings *settings{};
// key: UGCHandle_t which is the file handle (primary or preview) // key: UGCHandle_t which is the file handle (primary or preview)
// value: the mod id, true if UGCHandle_t of primary file | false if UGCHandle_t of preview file // value: the mod id, true if UGCHandle_t of primary file | false if UGCHandle_t of preview file
std::map<UGCHandle_t, QueryInfo> steam_ugc_queries{}; std::map<UGCHandle_t, QueryInfo> steam_ugc_queries{};
std::set<PublishedFileId_t> subscribed{}; // just to keep the running state of subscription std::set<PublishedFileId_t> subscribed{}; // just to keep the running state of subscription
public: public:
Ugc_Remote_Storage_Bridge(class Settings *settings); Ugc_Remote_Storage_Bridge(class Settings *settings);
~Ugc_Remote_Storage_Bridge(); ~Ugc_Remote_Storage_Bridge();
// called from Steam_UGC::SendQueryUGCRequest() after a successful query // called from Steam_UGC::SendQueryUGCRequest() after a successful query
void add_ugc_query_result(UGCHandle_t file_handle, PublishedFileId_t fileid, bool handle_of_primary_file); void add_ugc_query_result(UGCHandle_t file_handle, PublishedFileId_t fileid, bool handle_of_primary_file);
bool remove_ugc_query_result(UGCHandle_t file_handle); bool remove_ugc_query_result(UGCHandle_t file_handle);
std::optional<QueryInfo> get_ugc_query_result(UGCHandle_t file_handle) const; std::optional<QueryInfo> get_ugc_query_result(UGCHandle_t file_handle) const;
void add_subbed_mod(PublishedFileId_t id); void add_subbed_mod(PublishedFileId_t id);
void remove_subbed_mod(PublishedFileId_t id); void remove_subbed_mod(PublishedFileId_t id);
size_t subbed_mods_count() const; size_t subbed_mods_count() const;
bool has_subbed_mod(PublishedFileId_t id) const; bool has_subbed_mod(PublishedFileId_t id) const;
std::set<PublishedFileId_t>::iterator subbed_mods_itr_begin() const; std::set<PublishedFileId_t>::iterator subbed_mods_itr_begin() const;
std::set<PublishedFileId_t>::iterator subbed_mods_itr_end() const; std::set<PublishedFileId_t>::iterator subbed_mods_itr_end() const;
}; };
#endif // __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__ #endif // __INCLUDED_UGC_REMOTE_STORAGE_BRIDGE_H__

140
game_overlay_renderer_lib/game_overlay_renderer_lib.h
View file

@ -1,70 +1,70 @@
// this library is sometimes needed because some apps (like appid 410900) will check // this library is sometimes needed because some apps (like appid 410900) will check
// for its existence inside their memory space during runtime, // for its existence inside their memory space during runtime,
// otherwise they'll trigger custom nagging stuff // otherwise they'll trigger custom nagging stuff
// notice how functions return a boolean result as uint32 not bool // notice how functions return a boolean result as uint32 not bool
// the return value is placed inside the entire 'eax' register, not just 'al' // the return value is placed inside the entire 'eax' register, not just 'al'
// you have to disassem both 32-bit and 64-bit libraries to see this nonsense // you have to disassem both 32-bit and 64-bit libraries to see this nonsense
// ex: 32-bit ValveIsScreenshotsHooked(): mov al, byte ptr ds:[0x7AF62DA1] // ex: 32-bit ValveIsScreenshotsHooked(): mov al, byte ptr ds:[0x7AF62DA1]
// 64-bit ValveIsScreenshotsHooked(): movzx eax, byte ptr ds:[0x00007FF8938F235D] // 64-bit ValveIsScreenshotsHooked(): movzx eax, byte ptr ds:[0x00007FF8938F235D]
#ifndef __GAME_OVERLAY_RENDERER_LIB_H__ #ifndef __GAME_OVERLAY_RENDERER_LIB_H__
#define __GAME_OVERLAY_RENDERER_LIB_H__ #define __GAME_OVERLAY_RENDERER_LIB_H__
#include "dll/common_includes.h" #include "dll/common_includes.h"
S_API_EXPORT steam_bool S_CALLTYPE BOverlayNeedsPresent(); S_API_EXPORT steam_bool S_CALLTYPE BOverlayNeedsPresent();
S_API_EXPORT steam_bool S_CALLTYPE IsOverlayEnabled(); S_API_EXPORT steam_bool S_CALLTYPE IsOverlayEnabled();
S_API_EXPORT void S_CALLTYPE OverlayHookD3D3(void *param_1, void *param_2); S_API_EXPORT void S_CALLTYPE OverlayHookD3D3(void *param_1, void *param_2);
S_API_EXPORT void S_CALLTYPE SetNotificationInset(int32 param_1, int32 param_2); S_API_EXPORT void S_CALLTYPE SetNotificationInset(int32 param_1, int32 param_2);
S_API_EXPORT void S_CALLTYPE SetNotificationPosition(ENotificationPosition param_1); S_API_EXPORT void S_CALLTYPE SetNotificationPosition(ENotificationPosition param_1);
S_API_EXPORT steam_bool S_CALLTYPE SteamOverlayIsUsingGamepad(); S_API_EXPORT steam_bool S_CALLTYPE SteamOverlayIsUsingGamepad();
S_API_EXPORT steam_bool S_CALLTYPE SteamOverlayIsUsingKeyboard(); S_API_EXPORT steam_bool S_CALLTYPE SteamOverlayIsUsingKeyboard();
S_API_EXPORT void S_CALLTYPE ValveHookScreenshots(bool param_1); S_API_EXPORT void S_CALLTYPE ValveHookScreenshots(bool param_1);
S_API_EXPORT steam_bool S_CALLTYPE ValveIsScreenshotsHooked(); S_API_EXPORT steam_bool S_CALLTYPE ValveIsScreenshotsHooked();
// only available for 32-bit lib on Windows // only available for 32-bit lib on Windows
// the function takes 2 arguments, but they're expected to be at [esp] & [esp+4] // the function takes 2 arguments, but they're expected to be at [esp] & [esp+4]
// notice how the top of the stack is not the return address, but param 1 // notice how the top of the stack is not the return address, but param 1
// this function might be designed to be invoked via a jmp instruction, // this function might be designed to be invoked via a jmp instruction,
// at the end it does this: // at the end it does this:
// popad // pop all 8 general purpose registers // popad // pop all 8 general purpose registers
// popfd // pop flags register // popfd // pop flags register
// ret // regular return // ret // regular return
// notice how it eventually deallocates 8+1 registers (4 bytes * 9), // notice how it eventually deallocates 8+1 registers (4 bytes * 9),
// meaning that (4 bytes * 2 input params) + (4 bytes * 9) are deallocated from the stack // meaning that (4 bytes * 2 input params) + (4 bytes * 9) are deallocated from the stack
// note: this is not marked S_API_EXPORT, because later we'll use a linker pragma // note: this is not marked S_API_EXPORT, because later we'll use a linker pragma
// to both export this function, and prevent __stdcall name mangling // to both export this function, and prevent __stdcall name mangling
#if defined(__WINDOWS_32__) #if defined(__WINDOWS_32__)
void __stdcall VirtualFreeWrapper( void __stdcall VirtualFreeWrapper(
void *param_1, void *param_2, void *param_1, void *param_2,
void *stack_cleanup_1, void *stack_cleanup_2, void *stack_cleanup_3, void *stack_cleanup_4, void *stack_cleanup_5, void *stack_cleanup_1, void *stack_cleanup_2, void *stack_cleanup_3, void *stack_cleanup_4, void *stack_cleanup_5,
void *stack_cleanup_6, void *stack_cleanup_7, void *stack_cleanup_8, void *stack_cleanup_9 void *stack_cleanup_6, void *stack_cleanup_7, void *stack_cleanup_8, void *stack_cleanup_9
); );
#endif // __WINDOWS_32__ #endif // __WINDOWS_32__
S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayGetScaleFactors(float *param_1, float *param_2); S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayGetScaleFactors(float *param_1, float *param_2);
S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayPresent( S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayPresent(
void *param_1, int32 param_2, int32 param_3, void *param_4, void * param_5, void *param_1, int32 param_2, int32 param_3, void *param_4, void * param_5,
void *param_6, void *param_7, void *param_8, void *param_9, void *param_10 void *param_6, void *param_7, void *param_8, void *param_9, void *param_10
); );
S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayProcessCapturedFrame( S_API_EXPORT void S_CALLTYPE VulkanSteamOverlayProcessCapturedFrame(
bool param_1, int32 param_2, int32 param_3, int32 param_4, void *param_5, void *param_6, int32 param_7, bool param_1, int32 param_2, int32 param_3, int32 param_4, void *param_5, void *param_6, int32 param_7,
int32 param_8, int32 param_9, int32 param_10, int32 param_11, int16 param_12, int16 param_13, int16 param_14 int32 param_8, int32 param_9, int32 param_10, int32 param_11, int16 param_12, int16 param_13, int16 param_14
); );
#endif // __GAME_OVERLAY_RENDERER_LIB_H__ #endif // __GAME_OVERLAY_RENDERER_LIB_H__

968
helpers/pe_helpers.cpp
View file

@ -1,484 +1,484 @@
#include "pe_helpers/pe_helpers.hpp" #include "pe_helpers/pe_helpers.hpp"
#include "common_helpers/common_helpers.hpp" #include "common_helpers/common_helpers.hpp"
#include <vector> #include <vector>
#include <utility> #include <utility>
#include <mutex> #include <mutex>
#include <cwchar> #include <cwchar>
static inline bool is_hex(const char c) static inline bool is_hex(const char c)
{ {
return (c >= '0' && c <= '9') || return (c >= '0' && c <= '9') ||
(c >= 'a' && c <= 'f') || (c >= 'a' && c <= 'f') ||
(c >= 'A' && c <= 'F'); (c >= 'A' && c <= 'F');
} }
static inline uint8_t char_to_byte(const char c) static inline uint8_t char_to_byte(const char c)
{ {
if (c >= '0' && c <= '9') return (uint8_t)(c - '0'); if (c >= '0' && c <= '9') return (uint8_t)(c - '0');
if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a') + 0xa; if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a') + 0xa;
if (c >= 'A' && c <= 'F') return (uint8_t)(c - 'A') + 0xa; if (c >= 'A' && c <= 'F') return (uint8_t)(c - 'A') + 0xa;
return (uint8_t)c; return (uint8_t)c;
} }
PIMAGE_NT_HEADERS pe_helpers::get_nt_header(HMODULE hModule) PIMAGE_NT_HEADERS pe_helpers::get_nt_header(HMODULE hModule)
{ {
// https://dev.to/wireless90/validating-the-pe-signature-my-av-flagged-me-windows-pe-internals-2m5o/ // https://dev.to/wireless90/validating-the-pe-signature-my-av-flagged-me-windows-pe-internals-2m5o/
PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)(char*)hModule; PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)(char*)hModule;
if (dosHeader->e_magic != 0x5A4D) { // "MZ" if (dosHeader->e_magic != 0x5A4D) { // "MZ"
return nullptr; return nullptr;
} }
LONG newExeHeaderOffset = dosHeader->e_lfanew; LONG newExeHeaderOffset = dosHeader->e_lfanew;
PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((char*)hModule + newExeHeaderOffset); PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((char*)hModule + newExeHeaderOffset);
if (!ntHeader || ntHeader->Signature != 0x00004550) { // "PE\0\0" if (!ntHeader || ntHeader->Signature != 0x00004550) { // "PE\0\0"
return nullptr; return nullptr;
} }
return ntHeader; return ntHeader;
} }
PIMAGE_FILE_HEADER pe_helpers::get_file_header(HMODULE hModule) PIMAGE_FILE_HEADER pe_helpers::get_file_header(HMODULE hModule)
{ {
auto nt_header = get_nt_header(hModule); auto nt_header = get_nt_header(hModule);
return nt_header ? &nt_header->FileHeader : nullptr; return nt_header ? &nt_header->FileHeader : nullptr;
} }
PIMAGE_OPTIONAL_HEADER pe_helpers::get_optional_header(HMODULE hModule) PIMAGE_OPTIONAL_HEADER pe_helpers::get_optional_header(HMODULE hModule)
{ {
auto nt_header = get_nt_header(hModule); auto nt_header = get_nt_header(hModule);
return nt_header ? &nt_header->OptionalHeader : nullptr; return nt_header ? &nt_header->OptionalHeader : nullptr;
} }
uint8_t* pe_helpers::search_memory(uint8_t *mem, size_t size, const std::string &search_patt) uint8_t* pe_helpers::search_memory(uint8_t *mem, size_t size, const std::string &search_patt)
{ {
if (!mem || !size || search_patt.empty()) return nullptr; if (!mem || !size || search_patt.empty()) return nullptr;
if (search_patt.find_first_not_of(" \t", 0) == std::string::npos) { if (search_patt.find_first_not_of(" \t", 0) == std::string::npos) {
return nullptr; // empty search patt return nullptr; // empty search patt
} }
const uint8_t *end = mem + size; const uint8_t *end = mem + size;
for (uint8_t *base = mem; base < end; ++base) for (uint8_t *base = mem; base < end; ++base)
{ {
// incremental offset after each byte match // incremental offset after each byte match
size_t search_patt_offset = 0; size_t search_patt_offset = 0;
bool error = false; bool error = false;
for (const uint8_t *displacement = base; displacement < end; ++displacement) for (const uint8_t *displacement = base; displacement < end; ++displacement)
{ {
uint8_t mask = 0xFF; uint8_t mask = 0xFF;
uint8_t s_byte = 0; uint8_t s_byte = 0;
// skip spaces // skip spaces
search_patt_offset = search_patt.find_first_not_of(" \t", search_patt_offset); search_patt_offset = search_patt.find_first_not_of(" \t", search_patt_offset);
if (search_patt_offset == std::string::npos) { if (search_patt_offset == std::string::npos) {
break; break;
} }
const auto this_char = search_patt[search_patt_offset]; const auto this_char = search_patt[search_patt_offset];
const auto next_char = (search_patt_offset + 1) < search_patt.size() const auto next_char = (search_patt_offset + 1) < search_patt.size()
? search_patt[search_patt_offset + 1] ? search_patt[search_patt_offset + 1]
: '\0'; : '\0';
if (this_char == '?') { if (this_char == '?') {
if (next_char == '?' || // "??" if (next_char == '?' || // "??"
next_char == ' ' || // "? " next_char == ' ' || // "? "
next_char == 't') { // "? " next_char == 't') { // "? "
mask = 0x00; mask = 0x00;
s_byte = 0; s_byte = 0;
} else if (is_hex(next_char)) { // "?c" } else if (is_hex(next_char)) { // "?c"
mask = 0x0F; mask = 0x0F;
s_byte = char_to_byte(next_char); s_byte = char_to_byte(next_char);
} else { // unknown } else { // unknown
return nullptr; return nullptr;
} }
// skip // skip
search_patt_offset += 2; search_patt_offset += 2;
} else if (is_hex(this_char)) { } else if (is_hex(this_char)) {
if (next_char == '?') { // "c?" if (next_char == '?') { // "c?"
mask = 0xF0; mask = 0xF0;
s_byte = char_to_byte(this_char) << 4; s_byte = char_to_byte(this_char) << 4;
} else if (is_hex(next_char)) { // "34" } else if (is_hex(next_char)) { // "34"
mask = 0xFF; mask = 0xFF;
s_byte = (char_to_byte(this_char) << 4) | char_to_byte(next_char); s_byte = (char_to_byte(this_char) << 4) | char_to_byte(next_char);
} else { // unknown } else { // unknown
return nullptr; return nullptr;
} }
// skip // skip
search_patt_offset += 2; search_patt_offset += 2;
} else { // unknown } else { // unknown
return nullptr; return nullptr;
} }
if ((*displacement & mask) != (s_byte & mask)) { if ((*displacement & mask) != (s_byte & mask)) {
error = true; error = true;
break; break;
} }
} }
if (!error && (search_patt_offset >= search_patt.size())) { if (!error && (search_patt_offset >= search_patt.size())) {
return base; return base;
} }
} }
return nullptr; return nullptr;
} }
bool pe_helpers::replace_memory(uint8_t *mem, size_t size, const std::string &replace_patt, HANDLE hProcess) bool pe_helpers::replace_memory(uint8_t *mem, size_t size, const std::string &replace_patt, HANDLE hProcess)
{ {
if (!mem || !size || replace_patt.empty()) return false; if (!mem || !size || replace_patt.empty()) return false;
size_t replace_patt_offset = replace_patt.find_first_not_of(" \t", 0); size_t replace_patt_offset = replace_patt.find_first_not_of(" \t", 0);
if (replace_patt_offset == std::string::npos) { if (replace_patt_offset == std::string::npos) {
return false; // empty patt return false; // empty patt
} }
// mask - byte // mask - byte
std::vector<std::pair<uint8_t, uint8_t>> replace_bytes{}; std::vector<std::pair<uint8_t, uint8_t>> replace_bytes{};
for (; for (;
replace_patt_offset < replace_patt.size(); replace_patt_offset < replace_patt.size();
replace_patt_offset = replace_patt.find_first_not_of(" \t", replace_patt_offset)) { replace_patt_offset = replace_patt.find_first_not_of(" \t", replace_patt_offset)) {
const auto this_char = replace_patt[replace_patt_offset]; const auto this_char = replace_patt[replace_patt_offset];
const auto next_char = (replace_patt_offset + 1) < replace_patt.size() const auto next_char = (replace_patt_offset + 1) < replace_patt.size()
? replace_patt[replace_patt_offset + 1] ? replace_patt[replace_patt_offset + 1]
: '\0'; : '\0';
if (this_char == '?') { if (this_char == '?') {
if (next_char == '?' || // "??" if (next_char == '?' || // "??"
next_char == ' ' || // "? " next_char == ' ' || // "? "
next_char == 't') { // "? " next_char == 't') { // "? "
replace_bytes.push_back({ replace_bytes.push_back({
0x00, 0x00,
0, 0,
}); });
} else if (is_hex(next_char)) { // "?c" } else if (is_hex(next_char)) { // "?c"
replace_bytes.push_back({ replace_bytes.push_back({
0x0F, 0x0F,
char_to_byte(next_char), char_to_byte(next_char),
}); });
} else { // unknown } else { // unknown
return false; return false;
} }
// skip // skip
replace_patt_offset += 2; replace_patt_offset += 2;
} else if (is_hex(this_char)) { } else if (is_hex(this_char)) {
if (next_char == '?') { // "c?" if (next_char == '?') { // "c?"
replace_bytes.push_back({ replace_bytes.push_back({
0xF0, 0xF0,
char_to_byte(this_char) << 4, char_to_byte(this_char) << 4,
}); });
} else if (is_hex(next_char)) { // "34" } else if (is_hex(next_char)) { // "34"
replace_bytes.push_back({ replace_bytes.push_back({
0xFF, 0xFF,
(char_to_byte(this_char) << 4) | char_to_byte(next_char), (char_to_byte(this_char) << 4) | char_to_byte(next_char),
}); });
} else { // unknown } else { // unknown
return false; return false;
} }
// skip // skip
replace_patt_offset += 2; replace_patt_offset += 2;
} else { // unknown } else { // unknown
return false; return false;
} }
} }
// remove trailing "??" // remove trailing "??"
// while last element == "??" // while last element == "??"
while (replace_bytes.size() && while (replace_bytes.size() &&
replace_bytes.back().first == 0x00) replace_bytes.back().first == 0x00)
{ {
replace_bytes.pop_back(); replace_bytes.pop_back();
} }
if (replace_bytes.empty() || replace_bytes.size() > size) return false; if (replace_bytes.empty() || replace_bytes.size() > size) return false;
// change protection // change protection
DWORD current_protection = 0; DWORD current_protection = 0;
if (!VirtualProtectEx(hProcess, mem, replace_bytes.size(), PAGE_READWRITE, &current_protection)) { if (!VirtualProtectEx(hProcess, mem, replace_bytes.size(), PAGE_READWRITE, &current_protection)) {
return false; return false;
} }
for (auto &rp : replace_bytes) { for (auto &rp : replace_bytes) {
if (rp.first == 0x00) { if (rp.first == 0x00) {
++mem; ++mem;
continue; continue;
} }
const uint8_t b_mem = (uint8_t)(*mem & (uint8_t)~rp.first); const uint8_t b_mem = (uint8_t)(*mem & (uint8_t)~rp.first);
const uint8_t b_replace = (uint8_t)(rp.second & rp.first); const uint8_t b_replace = (uint8_t)(rp.second & rp.first);
const uint8_t new_b_mem = b_mem | b_replace; const uint8_t new_b_mem = b_mem | b_replace;
*mem = b_mem | b_replace; *mem = b_mem | b_replace;
++mem; ++mem;
} }
// restore protection // restore protection
if (!VirtualProtectEx(hProcess, mem, replace_bytes.size(), current_protection, &current_protection)) { if (!VirtualProtectEx(hProcess, mem, replace_bytes.size(), current_protection, &current_protection)) {
return false; return false;
} }
return true; return true;
} }
// https://learn.microsoft.com/en-us/windows/win32/debug/retrieving-the-last-error-code // https://learn.microsoft.com/en-us/windows/win32/debug/retrieving-the-last-error-code
std::string pe_helpers::get_err_string(DWORD code) std::string pe_helpers::get_err_string(DWORD code)
{ {
std::string err_str(8192, '\0'); std::string err_str(8192, '\0');
DWORD msg_chars = FormatMessageA( DWORD msg_chars = FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, NULL,
code, code,
MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
(LPSTR)&err_str[0], (LPSTR)&err_str[0],
static_cast<DWORD>(err_str.size()), static_cast<DWORD>(err_str.size()),
NULL); NULL);
if (!msg_chars) return std::string(); if (!msg_chars) return std::string();
err_str = err_str.substr(0, msg_chars); err_str = err_str.substr(0, msg_chars);
return err_str; return err_str;
} }
bool pe_helpers::is_module_64(HMODULE hModule) bool pe_helpers::is_module_64(HMODULE hModule)
{ {
auto file_header = get_file_header(hModule); auto file_header = get_file_header(hModule);
return file_header ? (file_header->Machine == IMAGE_FILE_MACHINE_AMD64) : false; return file_header ? (file_header->Machine == IMAGE_FILE_MACHINE_AMD64) : false;
} }
bool pe_helpers::is_module_32(HMODULE hModule) bool pe_helpers::is_module_32(HMODULE hModule)
{ {
auto file_header = get_file_header(hModule); auto file_header = get_file_header(hModule);
return file_header ? (file_header->Machine == IMAGE_FILE_MACHINE_I386) : false; return file_header ? (file_header->Machine == IMAGE_FILE_MACHINE_I386) : false;
} }
pe_helpers::SectionHeadersResult pe_helpers::get_section_headers(HMODULE hModule) pe_helpers::SectionHeadersResult pe_helpers::get_section_headers(HMODULE hModule)
{ {
PIMAGE_NT_HEADERS ntHeader = get_nt_header(hModule); PIMAGE_NT_HEADERS ntHeader = get_nt_header(hModule);
PIMAGE_OPTIONAL_HEADER optionalHeader = &ntHeader->OptionalHeader; PIMAGE_OPTIONAL_HEADER optionalHeader = &ntHeader->OptionalHeader;
PIMAGE_FILE_HEADER fileHeader = get_file_header(hModule); PIMAGE_FILE_HEADER fileHeader = get_file_header(hModule);
WORD optionalHeadrSize = fileHeader->SizeOfOptionalHeader; WORD optionalHeadrSize = fileHeader->SizeOfOptionalHeader;
struct SectionHeadersResult res {}; struct SectionHeadersResult res {};
res.count = fileHeader->NumberOfSections; res.count = fileHeader->NumberOfSections;
res.ptr = fileHeader->NumberOfSections res.ptr = fileHeader->NumberOfSections
? (PIMAGE_SECTION_HEADER)((char *)optionalHeader + optionalHeadrSize) ? (PIMAGE_SECTION_HEADER)((char *)optionalHeader + optionalHeadrSize)
: nullptr; : nullptr;
return res; return res;
} }
PIMAGE_SECTION_HEADER pe_helpers::get_section_header_with_name(HMODULE hModule, const char *name) PIMAGE_SECTION_HEADER pe_helpers::get_section_header_with_name(HMODULE hModule, const char *name)
{ {
if (!name) return nullptr; if (!name) return nullptr;
auto res = get_section_headers(hModule); auto res = get_section_headers(hModule);
if (!res.count) return nullptr; if (!res.count) return nullptr;
for (size_t i = 0; i < res.count; ++i) { for (size_t i = 0; i < res.count; ++i) {
if (strncmp((const char *)res.ptr[i].Name, name, sizeof(res.ptr[i].Name)) == 0) { if (strncmp((const char *)res.ptr[i].Name, name, sizeof(res.ptr[i].Name)) == 0) {
return &res.ptr[i]; return &res.ptr[i];
} }
} }
return nullptr; return nullptr;
} }
DWORD pe_helpers::loadlib_remote(HANDLE hProcess, const std::string &fullpath, const char** err_reason) DWORD pe_helpers::loadlib_remote(HANDLE hProcess, const std::string &fullpath, const char** err_reason)
{ {
const auto lib_fullpath = common_helpers::to_wstr(fullpath); const auto lib_fullpath = common_helpers::to_wstr(fullpath);
if (lib_fullpath.empty()) { if (lib_fullpath.empty()) {
if (err_reason) { if (err_reason) {
*err_reason = "Failed to convert path to wide string"; *err_reason = "Failed to convert path to wide string";
} }
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
} }
// create a remote page // create a remote page
const size_t lib_path_str_bytes = (lib_fullpath.size() + 1) * sizeof(lib_fullpath[0]); const size_t lib_path_str_bytes = (lib_fullpath.size() + 1) * sizeof(lib_fullpath[0]);
LPVOID lib_remote_page = VirtualAllocEx( LPVOID lib_remote_page = VirtualAllocEx(
hProcess, hProcess,
NULL, NULL,
lib_path_str_bytes + sizeof(lib_fullpath[0]) * 2, // *2 just to be safe lib_path_str_bytes + sizeof(lib_fullpath[0]) * 2, // *2 just to be safe
MEM_RESERVE | MEM_COMMIT, MEM_RESERVE | MEM_COMMIT,
PAGE_READWRITE PAGE_READWRITE
); );
if (!lib_remote_page) { if (!lib_remote_page) {
if (err_reason) { if (err_reason) {
*err_reason = "Failed to remotely allocate page with VirtualAllocEx()"; *err_reason = "Failed to remotely allocate page with VirtualAllocEx()";
} }
return GetLastError(); return GetLastError();
} }
SIZE_T bytes_written = 0; SIZE_T bytes_written = 0;
BOOL written = WriteProcessMemory( BOOL written = WriteProcessMemory(
hProcess, hProcess,
lib_remote_page, lib_remote_page,
(LPCVOID)&lib_fullpath[0], (LPCVOID)&lib_fullpath[0],
lib_path_str_bytes, lib_path_str_bytes,
&bytes_written &bytes_written
); );
if (!written || (bytes_written < lib_path_str_bytes)) { if (!written || (bytes_written < lib_path_str_bytes)) {
// cleanup allcoated page // cleanup allcoated page
VirtualFreeEx( VirtualFreeEx(
hProcess, hProcess,
lib_remote_page, lib_remote_page,
0, 0,
MEM_RELEASE MEM_RELEASE
); );
if (err_reason) { if (err_reason) {
*err_reason = "Failed to remotely write dll path with WriteProcessMemory()"; *err_reason = "Failed to remotely write dll path with WriteProcessMemory()";
} }
return GetLastError(); return GetLastError();
} }
// call LoadLibraryW() and pass the dll fullpath // call LoadLibraryW() and pass the dll fullpath
HANDLE remote_thread = CreateRemoteThread( HANDLE remote_thread = CreateRemoteThread(
hProcess, hProcess,
NULL, NULL,
0, 0,
(LPTHREAD_START_ROUTINE)LoadLibraryW, (LPTHREAD_START_ROUTINE)LoadLibraryW,
lib_remote_page, lib_remote_page,
0, 0,
NULL NULL
); );
if (!remote_thread) { if (!remote_thread) {
// cleanup allcoated page // cleanup allcoated page
VirtualFreeEx( VirtualFreeEx(
hProcess, hProcess,
lib_remote_page, lib_remote_page,
0, 0,
MEM_RELEASE MEM_RELEASE
); );
if (err_reason) { if (err_reason) {
*err_reason = "Failed to create/run remote thread with CreateRemoteThread()"; *err_reason = "Failed to create/run remote thread with CreateRemoteThread()";
} }
return GetLastError(); return GetLastError();
} }
// wait for DllMain // wait for DllMain
WaitForSingleObject(remote_thread, INFINITE); WaitForSingleObject(remote_thread, INFINITE);
CloseHandle(remote_thread); CloseHandle(remote_thread);
// cleanup allcoated page // cleanup allcoated page
VirtualFreeEx( VirtualFreeEx(
hProcess, hProcess,
lib_remote_page, lib_remote_page,
0, 0,
MEM_RELEASE MEM_RELEASE
); );
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
size_t pe_helpers::get_pe_size(HMODULE hModule) size_t pe_helpers::get_pe_size(HMODULE hModule)
{ {
// https://stackoverflow.com/a/34695773 // https://stackoverflow.com/a/34695773
// https://learn.microsoft.com/en-us/windows/win32/debug/pe-format // https://learn.microsoft.com/en-us/windows/win32/debug/pe-format
// "The PE file header consists of a Microsoft MS-DOS stub, the PE signature, the COFF file header, and an optional header" // "The PE file header consists of a Microsoft MS-DOS stub, the PE signature, the COFF file header, and an optional header"
// "The combined size of an MS-DOS stub, PE header, and section headers rounded up to a multiple of FileAlignment." // "The combined size of an MS-DOS stub, PE header, and section headers rounded up to a multiple of FileAlignment."
size_t size = get_optional_header(hModule)->SizeOfHeaders; size_t size = get_optional_header(hModule)->SizeOfHeaders;
SectionHeadersResult headers = get_section_headers(hModule); SectionHeadersResult headers = get_section_headers(hModule);
for (size_t i = 0; i < headers.count; ++i) { for (size_t i = 0; i < headers.count; ++i) {
size += headers.ptr[i].SizeOfRawData; size += headers.ptr[i].SizeOfRawData;
} }
return size; return size;
} }
static std::string path_a{}; static std::string path_a{};
static std::string modulename_a{}; static std::string modulename_a{};
const std::string& pe_helpers::get_current_exe_path() const std::string& pe_helpers::get_current_exe_path()
{ {
static std::recursive_mutex path_mtx{}; static std::recursive_mutex path_mtx{};
if (path_a.empty()) { if (path_a.empty()) {
std::lock_guard lk(path_mtx); std::lock_guard lk(path_mtx);
if (path_a.empty()) { if (path_a.empty()) {
DWORD err = GetLastError(); DWORD err = GetLastError();
std::wstring path_w(8192, '\0'); std::wstring path_w(8192, '\0');
DWORD read_chars = GetModuleFileNameW(GetModuleHandleW(nullptr), &path_w[0], (DWORD)path_w.size()); DWORD read_chars = GetModuleFileNameW(GetModuleHandleW(nullptr), &path_w[0], (DWORD)path_w.size());
if (read_chars >= path_w.size()) { if (read_chars >= path_w.size()) {
path_w.resize(read_chars); path_w.resize(read_chars);
read_chars = GetModuleFileNameW(GetModuleHandleW(nullptr), &path_w[0], (DWORD)path_w.size()); read_chars = GetModuleFileNameW(GetModuleHandleW(nullptr), &path_w[0], (DWORD)path_w.size());
} }
if ((read_chars < path_w.size()) && path_w[0]) { if ((read_chars < path_w.size()) && path_w[0]) {
auto modulename_idx = path_w.find_last_of(L"\\/") + 1; auto modulename_idx = path_w.find_last_of(L"\\/") + 1;
modulename_a = common_helpers::to_str(path_w.substr(modulename_idx, read_chars - modulename_idx)); modulename_a = common_helpers::to_str(path_w.substr(modulename_idx, read_chars - modulename_idx));
path_a = common_helpers::to_str(path_w.substr(0, modulename_idx)); path_a = common_helpers::to_str(path_w.substr(0, modulename_idx));
} }
SetLastError(err); SetLastError(err);
} }
} }
return path_a; return path_a;
} }
const std::string& pe_helpers::get_current_exe_name() const std::string& pe_helpers::get_current_exe_name()
{ {
if (modulename_a.empty()) { if (modulename_a.empty()) {
get_current_exe_path(); get_current_exe_path();
} }
return modulename_a; return modulename_a;
} }
bool pe_helpers::ends_with_i(PUNICODE_STRING target, std::wstring_view query) bool pe_helpers::ends_with_i(PUNICODE_STRING target, std::wstring_view query)
{ {
return common_helpers::ends_with_i( return common_helpers::ends_with_i(
std::wstring_view( target->Buffer, target->Length / sizeof(target->Buffer[0]) ), std::wstring_view( target->Buffer, target->Length / sizeof(target->Buffer[0]) ),
query query
); );
} }
MEMORY_BASIC_INFORMATION pe_helpers::get_mem_page_details(const void* mem) MEMORY_BASIC_INFORMATION pe_helpers::get_mem_page_details(const void* mem)
{ {
MEMORY_BASIC_INFORMATION mbi{}; MEMORY_BASIC_INFORMATION mbi{};
if (VirtualQuery(mem, &mbi, sizeof(mbi))) { if (VirtualQuery(mem, &mbi, sizeof(mbi))) {
return mbi; return mbi;
} else { } else {
return {}; return {};
} }
} }
size_t pe_helpers::get_current_exe_mem_size() size_t pe_helpers::get_current_exe_mem_size()
{ {
auto hmod = GetModuleHandleW(NULL); auto hmod = GetModuleHandleW(NULL);
size_t size = 0; size_t size = 0;
{ {
MEMORY_BASIC_INFORMATION mbi{}; MEMORY_BASIC_INFORMATION mbi{};
if (!VirtualQuery((LPVOID)hmod, &mbi, sizeof(mbi))) { if (!VirtualQuery((LPVOID)hmod, &mbi, sizeof(mbi))) {
return 0; return 0;
} }
size = mbi.RegionSize; // PE header size = mbi.RegionSize; // PE header
} }
auto sections = get_section_headers(hmod); auto sections = get_section_headers(hmod);
if (!sections.count) { if (!sections.count) {
return 0; return 0;
} }
for (size_t i = 0; i < sections.count; ++i) { for (size_t i = 0; i < sections.count; ++i) {
auto section = sections.ptr[i]; auto section = sections.ptr[i];
MEMORY_BASIC_INFORMATION mbi{}; MEMORY_BASIC_INFORMATION mbi{};
if (!VirtualQuery((LPCVOID)((uint8_t *)hmod + section.VirtualAddress), &mbi, sizeof(mbi))) { if (!VirtualQuery((LPCVOID)((uint8_t *)hmod + section.VirtualAddress), &mbi, sizeof(mbi))) {
return 0; return 0;
} }
size = mbi.RegionSize; // actual section size in mem size = mbi.RegionSize; // actual section size in mem
} }
return size; return size;
} }

110
helpers/pe_helpers/pe_helpers.hpp
View file

@ -1,55 +1,55 @@
#pragma once #pragma once
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#include <windows.h> #include <windows.h>
#include <winternl.h> #include <winternl.h>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <cstdint> #include <cstdint>
namespace pe_helpers namespace pe_helpers
{ {
typedef struct SectionHeadersResult typedef struct SectionHeadersResult
{ {
WORD count; WORD count;
PIMAGE_SECTION_HEADER ptr; PIMAGE_SECTION_HEADER ptr;
} SectionHeadersResult_t; } SectionHeadersResult_t;
PIMAGE_NT_HEADERS get_nt_header(HMODULE hModule); PIMAGE_NT_HEADERS get_nt_header(HMODULE hModule);
PIMAGE_FILE_HEADER get_file_header(HMODULE hModule); PIMAGE_FILE_HEADER get_file_header(HMODULE hModule);
PIMAGE_OPTIONAL_HEADER get_optional_header(HMODULE hModule); PIMAGE_OPTIONAL_HEADER get_optional_header(HMODULE hModule);
uint8_t* search_memory(uint8_t *mem, size_t size, const std::string &search_patt); uint8_t* search_memory(uint8_t *mem, size_t size, const std::string &search_patt);
bool replace_memory(uint8_t *mem, size_t size, const std::string &replace_patt, HANDLE hProcess); bool replace_memory(uint8_t *mem, size_t size, const std::string &replace_patt, HANDLE hProcess);
std::string get_err_string(DWORD code); std::string get_err_string(DWORD code);
bool is_module_64(HMODULE hModule); bool is_module_64(HMODULE hModule);
bool is_module_32(HMODULE hModule); bool is_module_32(HMODULE hModule);
SectionHeadersResult get_section_headers(HMODULE hModule); SectionHeadersResult get_section_headers(HMODULE hModule);
PIMAGE_SECTION_HEADER get_section_header_with_name(HMODULE hModule, const char* name); PIMAGE_SECTION_HEADER get_section_header_with_name(HMODULE hModule, const char* name);
DWORD loadlib_remote(HANDLE hProcess, const std::string &fullpath, const char** err_reason = nullptr); DWORD loadlib_remote(HANDLE hProcess, const std::string &fullpath, const char** err_reason = nullptr);
size_t get_pe_size(HMODULE hModule); size_t get_pe_size(HMODULE hModule);
const std::string& get_current_exe_path(); const std::string& get_current_exe_path();
const std::string& get_current_exe_name(); const std::string& get_current_exe_name();
bool ends_with_i(PUNICODE_STRING target, std::wstring_view query); bool ends_with_i(PUNICODE_STRING target, std::wstring_view query);
MEMORY_BASIC_INFORMATION get_mem_page_details(const void* mem); MEMORY_BASIC_INFORMATION get_mem_page_details(const void* mem);
size_t get_current_exe_mem_size(); size_t get_current_exe_mem_size();
} }

12
libs/detours/detours.h
View file

@ -381,10 +381,10 @@ extern const GUID DETOUR_EXE_RESTORE_GUID;
extern const GUID DETOUR_EXE_HELPER_GUID; extern const GUID DETOUR_EXE_HELPER_GUID;
#define DETOUR_TRAMPOLINE_SIGNATURE 0x21727444 // Dtr! #define DETOUR_TRAMPOLINE_SIGNATURE 0x21727444 // Dtr!
typedef struct _DETOUR_TRAMPOLINE DETOUR_TRAMPOLINE, *PDETOUR_TRAMPOLINE; typedef struct _DETOUR_TRAMPOLINE DETOUR_TRAMPOLINE, *PDETOUR_TRAMPOLINE;
#ifndef DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS #ifndef DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS
#define DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS 32 #define DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS 32
#endif // !DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS #endif // !DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS
/////////////////////////////////////////////////////////// Binary Structures. /////////////////////////////////////////////////////////// Binary Structures.
@ -594,8 +594,8 @@ PVOID WINAPI DetourCopyInstruction(_In_opt_ PVOID pDst,
BOOL WINAPI DetourSetCodeModule(_In_ HMODULE hModule, BOOL WINAPI DetourSetCodeModule(_In_ HMODULE hModule,
_In_ BOOL fLimitReferencesToModule); _In_ BOOL fLimitReferencesToModule);
PVOID WINAPI DetourAllocateRegionWithinJumpBounds(_In_ LPCVOID pbTarget, PVOID WINAPI DetourAllocateRegionWithinJumpBounds(_In_ LPCVOID pbTarget,
_Out_ PDWORD pcbAllocatedSize); _Out_ PDWORD pcbAllocatedSize);
BOOL WINAPI DetourIsFunctionImported(_In_ PBYTE pbCode, BOOL WINAPI DetourIsFunctionImported(_In_ PBYTE pbCode,
_In_ PBYTE pbAddress); _In_ PBYTE pbAddress);
///////////////////////////////////////////////////// Loaded Binary Functions. ///////////////////////////////////////////////////// Loaded Binary Functions.

4
libs/detours/disasm.cpp
View file

@ -1600,8 +1600,8 @@ const CDetourDis::COPYENTRY CDetourDis::s_rceCopyTable0F[] =
}; };
BOOL CDetourDis::SanityCheckSystem() BOOL CDetourDis::SanityCheckSystem()
{ {
C_ASSERT(ARRAYSIZE(CDetourDis::s_rceCopyTable) == 256); C_ASSERT(ARRAYSIZE(CDetourDis::s_rceCopyTable) == 256);
C_ASSERT(ARRAYSIZE(CDetourDis::s_rceCopyTable0F) == 256); C_ASSERT(ARRAYSIZE(CDetourDis::s_rceCopyTable0F) == 256);
return TRUE; return TRUE;
} }

2
libs/detours/image.cpp
View file

@ -1684,7 +1684,7 @@ BOOL CImage::Write(HANDLE hFile)
m_nNextFileAddr = Max(m_SectionHeaders[n].PointerToRawData + m_nNextFileAddr = Max(m_SectionHeaders[n].PointerToRawData +
m_SectionHeaders[n].SizeOfRawData, m_SectionHeaders[n].SizeOfRawData,
m_nNextFileAddr); m_nNextFileAddr);
// Old images have VirtualSize == 0 as a matter of course, e.g. NT 3.1. // Old images have VirtualSize == 0 as a matter of course, e.g. NT 3.1.
// In which case, use SizeOfRawData instead. // In which case, use SizeOfRawData instead.
m_nNextVirtAddr = Max(m_SectionHeaders[n].VirtualAddress + m_nNextVirtAddr = Max(m_SectionHeaders[n].VirtualAddress +
(m_SectionHeaders[n].Misc.VirtualSize (m_SectionHeaders[n].Misc.VirtualSize

802
overlay_experimental/fonts/binary_to_compressed_c.cpp.txt
View file

@ -1,402 +1,402 @@
// source: https://github.com/ocornut/imgui/blob/master/misc/fonts/binary_to_compressed_c.cpp // source: https://github.com/ocornut/imgui/blob/master/misc/fonts/binary_to_compressed_c.cpp
// ****************************************************************************************** // ******************************************************************************************
// ****************************************************************************************** // ******************************************************************************************
// ****************************************************************************************** // ******************************************************************************************
// dear imgui // dear imgui
// (binary_to_compressed_c.cpp) // (binary_to_compressed_c.cpp)
// Helper tool to turn a file into a C array, if you want to embed font data in your source code. // Helper tool to turn a file into a C array, if you want to embed font data in your source code.
// The data is first compressed with stb_compress() to reduce source code size, // The data is first compressed with stb_compress() to reduce source code size,
// then encoded in Base85 to fit in a string so we can fit roughly 4 bytes of compressed data into 5 bytes of source code (suggested by @mmalex) // then encoded in Base85 to fit in a string so we can fit roughly 4 bytes of compressed data into 5 bytes of source code (suggested by @mmalex)
// (If we used 32-bit constants it would require take 11 bytes of source code to encode 4 bytes, and be endianness dependent) // (If we used 32-bit constants it would require take 11 bytes of source code to encode 4 bytes, and be endianness dependent)
// Note that even with compression, the output array is likely to be bigger than the binary file.. // Note that even with compression, the output array is likely to be bigger than the binary file..
// Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF() // Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF()
// Build with, e.g: // Build with, e.g:
// # cl.exe binary_to_compressed_c.cpp // # cl.exe binary_to_compressed_c.cpp
// # g++ binary_to_compressed_c.cpp // # g++ binary_to_compressed_c.cpp
// # clang++ binary_to_compressed_c.cpp // # clang++ binary_to_compressed_c.cpp
// You can also find a precompiled Windows binary in the binary/demo package available from https://github.com/ocornut/imgui // You can also find a precompiled Windows binary in the binary/demo package available from https://github.com/ocornut/imgui
// Usage: // Usage:
// binary_to_compressed_c.exe [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname> // binary_to_compressed_c.exe [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname>
// Usage example: // Usage example:
// # binary_to_compressed_c.exe myfont.ttf MyFont > myfont.cpp // # binary_to_compressed_c.exe myfont.ttf MyFont > myfont.cpp
// # binary_to_compressed_c.exe -base85 myfont.ttf MyFont > myfont.cpp // # binary_to_compressed_c.exe -base85 myfont.ttf MyFont > myfont.cpp
#define _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
// stb_compress* from stb.h - declaration // stb_compress* from stb.h - declaration
typedef unsigned int stb_uint; typedef unsigned int stb_uint;
typedef unsigned char stb_uchar; typedef unsigned char stb_uchar;
stb_uint stb_compress(stb_uchar* out, stb_uchar* in, stb_uint len); stb_uint stb_compress(stb_uchar* out, stb_uchar* in, stb_uint len);
static bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static); static bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static);
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
if (argc < 3) if (argc < 3)
{ {
printf("Syntax: %s [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname>\n", argv[0]); printf("Syntax: %s [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname>\n", argv[0]);
return 0; return 0;
} }
int argn = 1; int argn = 1;
bool use_base85_encoding = false; bool use_base85_encoding = false;
bool use_compression = true; bool use_compression = true;
bool use_static = true; bool use_static = true;
while (argn < (argc - 2) && argv[argn][0] == '-') while (argn < (argc - 2) && argv[argn][0] == '-')
{ {
if (strcmp(argv[argn], "-base85") == 0) { use_base85_encoding = true; argn++; } if (strcmp(argv[argn], "-base85") == 0) { use_base85_encoding = true; argn++; }
else if (strcmp(argv[argn], "-nocompress") == 0) { use_compression = false; argn++; } else if (strcmp(argv[argn], "-nocompress") == 0) { use_compression = false; argn++; }
else if (strcmp(argv[argn], "-nostatic") == 0) { use_static = false; argn++; } else if (strcmp(argv[argn], "-nostatic") == 0) { use_static = false; argn++; }
else else
{ {
fprintf(stderr, "Unknown argument: '%s'\n", argv[argn]); fprintf(stderr, "Unknown argument: '%s'\n", argv[argn]);
return 1; return 1;
} }
} }
bool ret = binary_to_compressed_c(argv[argn], argv[argn + 1], use_base85_encoding, use_compression, use_static); bool ret = binary_to_compressed_c(argv[argn], argv[argn + 1], use_base85_encoding, use_compression, use_static);
if (!ret) if (!ret)
fprintf(stderr, "Error opening or reading file: '%s'\n", argv[argn]); fprintf(stderr, "Error opening or reading file: '%s'\n", argv[argn]);
return ret ? 0 : 1; return ret ? 0 : 1;
} }
char Encode85Byte(unsigned int x) char Encode85Byte(unsigned int x)
{ {
x = (x % 85) + 35; x = (x % 85) + 35;
return (char)((x >= '\\') ? x + 1 : x); return (char)((x >= '\\') ? x + 1 : x);
} }
bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static) bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static)
{ {
// Read file // Read file
FILE* f = fopen(filename, "rb"); FILE* f = fopen(filename, "rb");
if (!f) return false; if (!f) return false;
int data_sz; int data_sz;
if (fseek(f, 0, SEEK_END) || (data_sz = (int)ftell(f)) == -1 || fseek(f, 0, SEEK_SET)) { fclose(f); return false; } if (fseek(f, 0, SEEK_END) || (data_sz = (int)ftell(f)) == -1 || fseek(f, 0, SEEK_SET)) { fclose(f); return false; }
char* data = new char[data_sz + 4]; char* data = new char[data_sz + 4];
if (fread(data, 1, data_sz, f) != (size_t)data_sz) { fclose(f); delete[] data; return false; } if (fread(data, 1, data_sz, f) != (size_t)data_sz) { fclose(f); delete[] data; return false; }
memset((void*)(((char*)data) + data_sz), 0, 4); memset((void*)(((char*)data) + data_sz), 0, 4);
fclose(f); fclose(f);
// Compress // Compress
int maxlen = data_sz + 512 + (data_sz >> 2) + sizeof(int); // total guess int maxlen = data_sz + 512 + (data_sz >> 2) + sizeof(int); // total guess
char* compressed = use_compression ? new char[maxlen] : data; char* compressed = use_compression ? new char[maxlen] : data;
int compressed_sz = use_compression ? stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz) : data_sz; int compressed_sz = use_compression ? stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz) : data_sz;
if (use_compression) if (use_compression)
memset(compressed + compressed_sz, 0, maxlen - compressed_sz); memset(compressed + compressed_sz, 0, maxlen - compressed_sz);
// Output as Base85 encoded // Output as Base85 encoded
FILE* out = stdout; FILE* out = stdout;
fprintf(out, "// Exported using binary_to_compressed_c.cpp\n"); fprintf(out, "// Exported using binary_to_compressed_c.cpp\n");
const char* static_str = use_static ? "static " : ""; const char* static_str = use_static ? "static " : "";
const char* compressed_str = use_compression ? "compressed_" : ""; const char* compressed_str = use_compression ? "compressed_" : "";
if (use_base85_encoding) if (use_base85_encoding)
{ {
fprintf(out, "%sconst char %s_%sdata_base85[%d+1] =\n \"", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4) * 5); fprintf(out, "%sconst char %s_%sdata_base85[%d+1] =\n \"", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4) * 5);
char prev_c = 0; char prev_c = 0;
for (int src_i = 0; src_i < compressed_sz; src_i += 4) for (int src_i = 0; src_i < compressed_sz; src_i += 4)
{ {
// This is made a little more complicated by the fact that ??X sequences are interpreted as trigraphs by old C/C++ compilers. So we need to escape pairs of ??. // This is made a little more complicated by the fact that ??X sequences are interpreted as trigraphs by old C/C++ compilers. So we need to escape pairs of ??.
unsigned int d = *(unsigned int*)(compressed + src_i); unsigned int d = *(unsigned int*)(compressed + src_i);
for (unsigned int n5 = 0; n5 < 5; n5++, d /= 85) for (unsigned int n5 = 0; n5 < 5; n5++, d /= 85)
{ {
char c = Encode85Byte(d); char c = Encode85Byte(d);
fprintf(out, (c == '?' && prev_c == '?') ? "\\%c" : "%c", c); fprintf(out, (c == '?' && prev_c == '?') ? "\\%c" : "%c", c);
prev_c = c; prev_c = c;
} }
if ((src_i % 112) == 112 - 4) if ((src_i % 112) == 112 - 4)
fprintf(out, "\"\n \""); fprintf(out, "\"\n \"");
} }
fprintf(out, "\";\n\n"); fprintf(out, "\";\n\n");
} }
else else
{ {
fprintf(out, "%sconst unsigned int %s_%ssize = %d;\n", static_str, symbol, compressed_str, (int)compressed_sz); fprintf(out, "%sconst unsigned int %s_%ssize = %d;\n", static_str, symbol, compressed_str, (int)compressed_sz);
fprintf(out, "%sconst unsigned int %s_%sdata[%d/4] =\n{", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4) * 4); fprintf(out, "%sconst unsigned int %s_%sdata[%d/4] =\n{", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4) * 4);
int column = 0; int column = 0;
for (int i = 0; i < compressed_sz; i += 4) for (int i = 0; i < compressed_sz; i += 4)
{ {
unsigned int d = *(unsigned int*)(compressed + i); unsigned int d = *(unsigned int*)(compressed + i);
if ((column++ % 12) == 0) if ((column++ % 12) == 0)
fprintf(out, "\n 0x%08x, ", d); fprintf(out, "\n 0x%08x, ", d);
else else
fprintf(out, "0x%08x, ", d); fprintf(out, "0x%08x, ", d);
} }
fprintf(out, "\n};\n\n"); fprintf(out, "\n};\n\n");
} }
// Cleanup // Cleanup
delete[] data; delete[] data;
if (use_compression) if (use_compression)
delete[] compressed; delete[] compressed;
return true; return true;
} }
// stb_compress* from stb.h - definition // stb_compress* from stb.h - definition
//////////////////// compressor /////////////////////// //////////////////// compressor ///////////////////////
static stb_uint stb_adler32(stb_uint adler32, stb_uchar* buffer, stb_uint buflen) static stb_uint stb_adler32(stb_uint adler32, stb_uchar* buffer, stb_uint buflen)
{ {
const unsigned long ADLER_MOD = 65521; const unsigned long ADLER_MOD = 65521;
unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16; unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
unsigned long blocklen, i; unsigned long blocklen, i;
blocklen = buflen % 5552; blocklen = buflen % 5552;
while (buflen) { while (buflen) {
for (i = 0; i + 7 < blocklen; i += 8) { for (i = 0; i + 7 < blocklen; i += 8) {
s1 += buffer[0], s2 += s1; s1 += buffer[0], s2 += s1;
s1 += buffer[1], s2 += s1; s1 += buffer[1], s2 += s1;
s1 += buffer[2], s2 += s1; s1 += buffer[2], s2 += s1;
s1 += buffer[3], s2 += s1; s1 += buffer[3], s2 += s1;
s1 += buffer[4], s2 += s1; s1 += buffer[4], s2 += s1;
s1 += buffer[5], s2 += s1; s1 += buffer[5], s2 += s1;
s1 += buffer[6], s2 += s1; s1 += buffer[6], s2 += s1;
s1 += buffer[7], s2 += s1; s1 += buffer[7], s2 += s1;
buffer += 8; buffer += 8;
} }
for (; i < blocklen; ++i) for (; i < blocklen; ++i)
s1 += *buffer++, s2 += s1; s1 += *buffer++, s2 += s1;
s1 %= ADLER_MOD, s2 %= ADLER_MOD; s1 %= ADLER_MOD, s2 %= ADLER_MOD;
buflen -= blocklen; buflen -= blocklen;
blocklen = 5552; blocklen = 5552;
} }
return (s2 << 16) + s1; return (s2 << 16) + s1;
} }
static unsigned int stb_matchlen(stb_uchar* m1, stb_uchar* m2, stb_uint maxlen) static unsigned int stb_matchlen(stb_uchar* m1, stb_uchar* m2, stb_uint maxlen)
{ {
stb_uint i; stb_uint i;
for (i = 0; i < maxlen; ++i) for (i = 0; i < maxlen; ++i)
if (m1[i] != m2[i]) return i; if (m1[i] != m2[i]) return i;
return i; return i;
} }
// simple implementation that just takes the source data in a big block // simple implementation that just takes the source data in a big block
static stb_uchar* stb__out; static stb_uchar* stb__out;
static FILE* stb__outfile; static FILE* stb__outfile;
static stb_uint stb__outbytes; static stb_uint stb__outbytes;
static void stb__write(unsigned char v) static void stb__write(unsigned char v)
{ {
fputc(v, stb__outfile); fputc(v, stb__outfile);
++stb__outbytes; ++stb__outbytes;
} }
//#define stb_out(v) (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v))) //#define stb_out(v) (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v)))
#define stb_out(v) do { if (stb__out) *stb__out++ = (stb_uchar) (v); else stb__write((stb_uchar) (v)); } while (0) #define stb_out(v) do { if (stb__out) *stb__out++ = (stb_uchar) (v); else stb__write((stb_uchar) (v)); } while (0)
static void stb_out2(stb_uint v) { stb_out(v >> 8); stb_out(v); } static void stb_out2(stb_uint v) { stb_out(v >> 8); stb_out(v); }
static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); } static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16); stb_out(v >> 8); stb_out(v); } static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
static void outliterals(stb_uchar* in, int numlit) static void outliterals(stb_uchar* in, int numlit)
{ {
while (numlit > 65536) { while (numlit > 65536) {
outliterals(in, 65536); outliterals(in, 65536);
in += 65536; in += 65536;
numlit -= 65536; numlit -= 65536;
} }
if (numlit == 0); if (numlit == 0);
else if (numlit <= 32) stb_out(0x000020 + numlit - 1); else if (numlit <= 32) stb_out(0x000020 + numlit - 1);
else if (numlit <= 2048) stb_out2(0x000800 + numlit - 1); else if (numlit <= 2048) stb_out2(0x000800 + numlit - 1);
else /* numlit <= 65536) */ stb_out3(0x070000 + numlit - 1); else /* numlit <= 65536) */ stb_out3(0x070000 + numlit - 1);
if (stb__out) { if (stb__out) {
memcpy(stb__out, in, numlit); memcpy(stb__out, in, numlit);
stb__out += numlit; stb__out += numlit;
} }
else else
fwrite(in, 1, numlit, stb__outfile); fwrite(in, 1, numlit, stb__outfile);
} }
static int stb__window = 0x40000; // 256K static int stb__window = 0x40000; // 256K
static int stb_not_crap(int best, int dist) static int stb_not_crap(int best, int dist)
{ {
return ((best > 2 && dist <= 0x00100) return ((best > 2 && dist <= 0x00100)
|| (best > 5 && dist <= 0x04000) || (best > 5 && dist <= 0x04000)
|| (best > 7 && dist <= 0x80000)); || (best > 7 && dist <= 0x80000));
} }
static stb_uint stb__hashsize = 32768; static stb_uint stb__hashsize = 32768;
// note that you can play with the hashing functions all you // note that you can play with the hashing functions all you
// want without needing to change the decompressor // want without needing to change the decompressor
#define stb__hc(q,h,c) (((h) << 7) + ((h) >> 25) + q[c]) #define stb__hc(q,h,c) (((h) << 7) + ((h) >> 25) + q[c])
#define stb__hc2(q,h,c,d) (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d]) #define stb__hc2(q,h,c,d) (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d])
#define stb__hc3(q,c,d,e) ((q[c] << 14) + (q[d] << 7) + q[e]) #define stb__hc3(q,c,d,e) ((q[c] << 14) + (q[d] << 7) + q[e])
static unsigned int stb__running_adler; static unsigned int stb__running_adler;
static int stb_compress_chunk(stb_uchar* history, static int stb_compress_chunk(stb_uchar* history,
stb_uchar* start, stb_uchar* start,
stb_uchar* end, stb_uchar* end,
int length, int length,
int* pending_literals, int* pending_literals,
stb_uchar** chash, stb_uchar** chash,
stb_uint mask) stb_uint mask)
{ {
(void)history; (void)history;
int window = stb__window; int window = stb__window;
stb_uint match_max; stb_uint match_max;
stb_uchar* lit_start = start - *pending_literals; stb_uchar* lit_start = start - *pending_literals;
stb_uchar* q = start; stb_uchar* q = start;
#define STB__SCRAMBLE(h) (((h) + ((h) >> 16)) & mask) #define STB__SCRAMBLE(h) (((h) + ((h) >> 16)) & mask)
// stop short of the end so we don't scan off the end doing // stop short of the end so we don't scan off the end doing
// the hashing; this means we won't compress the last few bytes // the hashing; this means we won't compress the last few bytes
// unless they were part of something longer // unless they were part of something longer
while (q < start + length && q + 12 < end) { while (q < start + length && q + 12 < end) {
int m; int m;
stb_uint h1, h2, h3, h4, h; stb_uint h1, h2, h3, h4, h;
stb_uchar* t; stb_uchar* t;
int best = 2, dist = 0; int best = 2, dist = 0;
if (q + 65536 > end) if (q + 65536 > end)
match_max = (stb_uint)(end - q); match_max = (stb_uint)(end - q);
else else
match_max = 65536; match_max = 65536;
#define stb__nc(b,d) ((d) <= window && ((b) > 9 || stb_not_crap((int)(b),(int)(d)))) #define stb__nc(b,d) ((d) <= window && ((b) > 9 || stb_not_crap((int)(b),(int)(d))))
#define STB__TRY(t,p) /* avoid retrying a match we already tried */ \ #define STB__TRY(t,p) /* avoid retrying a match we already tried */ \
if (p ? dist != (int)(q-t) : 1) \ if (p ? dist != (int)(q-t) : 1) \
if ((m = stb_matchlen(t, q, match_max)) > best) \ if ((m = stb_matchlen(t, q, match_max)) > best) \
if (stb__nc(m,q-(t))) \ if (stb__nc(m,q-(t))) \
best = m, dist = (int)(q - (t)) best = m, dist = (int)(q - (t))
// rather than search for all matches, only try 4 candidate locations, // rather than search for all matches, only try 4 candidate locations,
// chosen based on 4 different hash functions of different lengths. // chosen based on 4 different hash functions of different lengths.
// this strategy is inspired by LZO; hashing is unrolled here using the // this strategy is inspired by LZO; hashing is unrolled here using the
// 'hc' macro // 'hc' macro
h = stb__hc3(q, 0, 1, 2); h1 = STB__SCRAMBLE(h); h = stb__hc3(q, 0, 1, 2); h1 = STB__SCRAMBLE(h);
t = chash[h1]; if (t) STB__TRY(t, 0); t = chash[h1]; if (t) STB__TRY(t, 0);
h = stb__hc2(q, h, 3, 4); h2 = STB__SCRAMBLE(h); h = stb__hc2(q, h, 3, 4); h2 = STB__SCRAMBLE(h);
h = stb__hc2(q, h, 5, 6); t = chash[h2]; if (t) STB__TRY(t, 1); h = stb__hc2(q, h, 5, 6); t = chash[h2]; if (t) STB__TRY(t, 1);
h = stb__hc2(q, h, 7, 8); h3 = STB__SCRAMBLE(h); h = stb__hc2(q, h, 7, 8); h3 = STB__SCRAMBLE(h);
h = stb__hc2(q, h, 9, 10); t = chash[h3]; if (t) STB__TRY(t, 1); h = stb__hc2(q, h, 9, 10); t = chash[h3]; if (t) STB__TRY(t, 1);
h = stb__hc2(q, h, 11, 12); h4 = STB__SCRAMBLE(h); h = stb__hc2(q, h, 11, 12); h4 = STB__SCRAMBLE(h);
t = chash[h4]; if (t) STB__TRY(t, 1); t = chash[h4]; if (t) STB__TRY(t, 1);
// because we use a shared hash table, can only update it // because we use a shared hash table, can only update it
// _after_ we've probed all of them // _after_ we've probed all of them
chash[h1] = chash[h2] = chash[h3] = chash[h4] = q; chash[h1] = chash[h2] = chash[h3] = chash[h4] = q;
if (best > 2) if (best > 2)
assert(dist > 0); assert(dist > 0);
// see if our best match qualifies // see if our best match qualifies
if (best < 3) { // fast path literals if (best < 3) { // fast path literals
++q; ++q;
} }
else if (best > 2 && best <= 0x80 && dist <= 0x100) { else if (best > 2 && best <= 0x80 && dist <= 0x100) {
outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best); outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best);
stb_out(0x80 + best - 1); stb_out(0x80 + best - 1);
stb_out(dist - 1); stb_out(dist - 1);
} }
else if (best > 5 && best <= 0x100 && dist <= 0x4000) { else if (best > 5 && best <= 0x100 && dist <= 0x4000) {
outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best); outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best);
stb_out2(0x4000 + dist - 1); stb_out2(0x4000 + dist - 1);
stb_out(best - 1); stb_out(best - 1);
} }
else if (best > 7 && best <= 0x100 && dist <= 0x80000) { else if (best > 7 && best <= 0x100 && dist <= 0x80000) {
outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best); outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best);
stb_out3(0x180000 + dist - 1); stb_out3(0x180000 + dist - 1);
stb_out(best - 1); stb_out(best - 1);
} }
else if (best > 8 && best <= 0x10000 && dist <= 0x80000) { else if (best > 8 && best <= 0x10000 && dist <= 0x80000) {
outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best); outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best);
stb_out3(0x100000 + dist - 1); stb_out3(0x100000 + dist - 1);
stb_out2(best - 1); stb_out2(best - 1);
} }
else if (best > 9 && dist <= 0x1000000) { else if (best > 9 && dist <= 0x1000000) {
if (best > 65536) best = 65536; if (best > 65536) best = 65536;
outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best); outliterals(lit_start, (int)(q - lit_start)); lit_start = (q += best);
if (best <= 0x100) { if (best <= 0x100) {
stb_out(0x06); stb_out(0x06);
stb_out3(dist - 1); stb_out3(dist - 1);
stb_out(best - 1); stb_out(best - 1);
} }
else { else {
stb_out(0x04); stb_out(0x04);
stb_out3(dist - 1); stb_out3(dist - 1);
stb_out2(best - 1); stb_out2(best - 1);
} }
} }
else { // fallback literals if no match was a balanced tradeoff else { // fallback literals if no match was a balanced tradeoff
++q; ++q;
} }
} }
// if we didn't get all the way, add the rest to literals // if we didn't get all the way, add the rest to literals
if (q - start < length) if (q - start < length)
q = start + length; q = start + length;
// the literals are everything from lit_start to q // the literals are everything from lit_start to q
*pending_literals = (int)(q - lit_start); *pending_literals = (int)(q - lit_start);
stb__running_adler = stb_adler32(stb__running_adler, start, (stb_uint)(q - start)); stb__running_adler = stb_adler32(stb__running_adler, start, (stb_uint)(q - start));
return (int)(q - start); return (int)(q - start);
} }
static int stb_compress_inner(stb_uchar* input, stb_uint length) static int stb_compress_inner(stb_uchar* input, stb_uint length)
{ {
int literals = 0; int literals = 0;
stb_uint len, i; stb_uint len, i;
stb_uchar** chash; stb_uchar** chash;
chash = (stb_uchar**)malloc(stb__hashsize * sizeof(stb_uchar*)); chash = (stb_uchar**)malloc(stb__hashsize * sizeof(stb_uchar*));
if (chash == nullptr) return 0; // failure if (chash == nullptr) return 0; // failure
for (i = 0; i < stb__hashsize; ++i) for (i = 0; i < stb__hashsize; ++i)
chash[i] = nullptr; chash[i] = nullptr;
// stream signature // stream signature
stb_out(0x57); stb_out(0xbc); stb_out(0x57); stb_out(0xbc);
stb_out2(0); stb_out2(0);
stb_out4(0); // 64-bit length requires 32-bit leading 0 stb_out4(0); // 64-bit length requires 32-bit leading 0
stb_out4(length); stb_out4(length);
stb_out4(stb__window); stb_out4(stb__window);
stb__running_adler = 1; stb__running_adler = 1;
len = stb_compress_chunk(input, input, input + length, length, &literals, chash, stb__hashsize - 1); len = stb_compress_chunk(input, input, input + length, length, &literals, chash, stb__hashsize - 1);
assert(len == length); assert(len == length);
outliterals(input + length - literals, literals); outliterals(input + length - literals, literals);
free(chash); free(chash);
stb_out2(0x05fa); // end opcode stb_out2(0x05fa); // end opcode
stb_out4(stb__running_adler); stb_out4(stb__running_adler);
return 1; // success return 1; // success
} }
stb_uint stb_compress(stb_uchar* out, stb_uchar* input, stb_uint length) stb_uint stb_compress(stb_uchar* out, stb_uchar* input, stb_uint length)
{ {
stb__out = out; stb__out = out;
stb__outfile = nullptr; stb__outfile = nullptr;
stb_compress_inner(input, length); stb_compress_inner(input, length);
return (stb_uint)(stb__out - out); return (stb_uint)(stb__out - out);
} }

404
post_build/steam_settings.EXAMPLE/fonts.EXAMPLE/Roboto-Medium-LICENSE.txt
View file

@ -1,202 +1,202 @@
Apache License Apache License
Version 2.0, January 2004 Version 2.0, January 2004
http://www.apache.org/licenses/ http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions. 1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, "License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document. and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by "Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License. the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all "Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition, control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the "control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity. outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity "You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License. exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, "Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation including but not limited to software source code, documentation
source, and configuration files. source, and configuration files.
"Object" form shall mean any form resulting from mechanical "Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation, not limited to compiled object code, generated documentation,
and conversions to other media types. and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or "Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work copyright notice that is included in or attached to the work
(an example is provided in the Appendix below). (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object "Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of, separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof. the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including "Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted" the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems, communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution." designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity "Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work. subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of 2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual, this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of, copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form. Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of 3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual, this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made, (except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work, use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s) Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate granted to You under this License for that Work shall terminate
as of the date such litigation is filed. as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the 4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You modifications, and in Source or Object form, provided that You
meet the following conditions: meet the following conditions:
(a) You must give any other recipients of the Work or (a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices (b) You must cause any modified files to carry prominent notices
stating that You changed the files; and stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works (c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work, attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of excluding those notices that do not pertain to any part of
the Derivative Works; and the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its (d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or, documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed that such additional attribution notices cannot be construed
as modifying the License. as modifying the License.
You may add Your own copyright statement to Your modifications and You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use, for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License. the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, 5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions. this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions. with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade 6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor, names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file. origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or 7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS, Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License. risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, 8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise, whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special, liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill, Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages. has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing 9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer, the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity, and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify, of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability. of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work. APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]" boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier same "printed page" as the copyright notice for easier
identification within third-party archives. identification within third-party archives.
Copyright [yyyy] [name of copyright owner] Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
You may obtain a copy of the License at You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and See the License for the specific language governing permissions and
limitations under the License. limitations under the License.

40
post_build/steam_settings.EXAMPLE/steam_interfaces.EXAMPLE.txt
View file

@ -1,20 +1,20 @@
SteamClient015 SteamClient015
SteamGameServer012 SteamGameServer012
SteamGameServerStats001 SteamGameServerStats001
SteamUser017 SteamUser017
SteamFriends014 SteamFriends014
SteamUtils007 SteamUtils007
SteamMatchMaking009 SteamMatchMaking009
SteamMatchMakingServers002 SteamMatchMakingServers002
STEAMUSERSTATS_INTERFACE_VERSION011 STEAMUSERSTATS_INTERFACE_VERSION011
STEAMAPPS_INTERFACE_VERSION006 STEAMAPPS_INTERFACE_VERSION006
SteamNetworking005 SteamNetworking005
STEAMREMOTESTORAGE_INTERFACE_VERSION012 STEAMREMOTESTORAGE_INTERFACE_VERSION012
STEAMSCREENSHOTS_INTERFACE_VERSION002 STEAMSCREENSHOTS_INTERFACE_VERSION002
STEAMHTTP_INTERFACE_VERSION002 STEAMHTTP_INTERFACE_VERSION002
STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001 STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001
STEAMCONTROLLER_INTERFACE_VERSION STEAMCONTROLLER_INTERFACE_VERSION
STEAMUGC_INTERFACE_VERSION002 STEAMUGC_INTERFACE_VERSION002
STEAMAPPLIST_INTERFACE_VERSION001 STEAMAPPLIST_INTERFACE_VERSION001
STEAMMUSIC_INTERFACE_VERSION001 STEAMMUSIC_INTERFACE_VERSION001
STEAMMUSICREMOTE_INTERFACE_VERSION001 STEAMMUSICREMOTE_INTERFACE_VERSION001

6
post_build/win/ColdClientLoader.EXAMPLE/extra_dlls.EXAMPLE/load_order.txt
View file

@ -1,3 +1,3 @@
dlls_subdir\3_my_third_dll.dll dlls_subdir\3_my_third_dll.dll
2_my_second_dll.dll 2_my_second_dll.dll

36
resources/README.md
View file

@ -1,18 +1,18 @@
This directory contains additional resources used during build. This directory contains additional resources used during build.
* The folder [win](./win/) contains the resources added to the .dll/.exe binaries, * The folder [win](./win/) contains the resources added to the .dll/.exe binaries,
these include version info and an immitation of any extra resources found in the original .dll/.exe. these include version info and an immitation of any extra resources found in the original .dll/.exe.
These resources are built using Microsoft's resourec compiler `rc.exe` during the build process, These resources are built using Microsoft's resourec compiler `rc.exe` during the build process,
and the output files are stored in `build\tmp\win\rsrc` as `*.res`. and the output files are stored in `build\tmp\win\rsrc` as `*.res`.
These resources are later passed to the compiler `cl.exe` as any normal `.cpp` or `.c` file: These resources are later passed to the compiler `cl.exe` as any normal `.cpp` or `.c` file:
```bash ```bash
cl.exe myfile.cpp myres.res -o myout.exe cl.exe myfile.cpp myres.res -o myout.exe
``` ```
* [api](./win/api/): contains an immitation of the resources found in `steam_api(64).dll` * [api](./win/api/): contains an immitation of the resources found in `steam_api(64).dll`
* [client](./win/client/): contains an immitation of the resources found in `steamclient(64).dll` * [client](./win/client/): contains an immitation of the resources found in `steamclient(64).dll`
* [launcher](./win/launcher/): contains an immitation of the resources found in `steam.exe` * [launcher](./win/launcher/): contains an immitation of the resources found in `steam.exe`
* [game_overlay_renderer](./win/game_overlay_renderer/): contains an immitation of the resources found in `GameOverlayRenderer(64).dll` * [game_overlay_renderer](./win/game_overlay_renderer/): contains an immitation of the resources found in `GameOverlayRenderer(64).dll`
* [file_dos_stub](./win/file_dos_stub/): contains an immitation of how the DOS stub is manipulated after build * [file_dos_stub](./win/file_dos_stub/): contains an immitation of how the DOS stub is manipulated after build

166
resources/win/api/32/resources.rc
View file

@ -1,83 +1,83 @@
// https://learn.microsoft.com/en-us/windows/win32/menurc/versioninfo-resource // https://learn.microsoft.com/en-us/windows/win32/menurc/versioninfo-resource
// https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo // https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,33,9,23 FILEVERSION 8,33,9,23
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "InternalName", "GSE Client API (win32)" VALUE "InternalName", "GSE Client API (win32)"
VALUE "FileVersion", "08.33.09.23" VALUE "FileVersion", "08.33.09.23"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.01" VALUE "ProductVersion", "01.00.00.01"
VALUE "FileDescription", "GSE Client API" VALUE "FileDescription", "GSE Client API"
VALUE "Source Control ID", "8330923" VALUE "Source Control ID", "8330923"
VALUE "OriginalFilename", "steam_api.dll" VALUE "OriginalFilename", "steam_api.dll"
VALUE "ProductName", "GSE Client API" VALUE "ProductName", "GSE Client API"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
/* /*
* +-------------------------+-------------------------+ * +-------------------------+-------------------------+
* | SubLanguage ID | Primary Language ID | * | SubLanguage ID | Primary Language ID |
* +-------------------------+-------------------------+ * +-------------------------+-------------------------+
* 15 10 9 0 * 15 10 9 0
*/ */
// 1033 = English - United States // 1033 = English - United States
// = 0x0409 // = 0x0409
// = 0000 0100 0000 1001 // = 0000 0100 0000 1001
// = // =
LANGUAGE 0x09, 0x01 // language = English, sublanguage = US LANGUAGE 0x09, 0x01 // language = English, sublanguage = US
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,1 FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE Client API" VALUE "FileDescription", "GSE Client API"
VALUE "FileVersion", "1, 0, 0, 1" VALUE "FileVersion", "1, 0, 0, 1"
VALUE "InternalName", "GSE Client API" VALUE "InternalName", "GSE Client API"
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "OriginalFilename", "steam_api.dll" VALUE "OriginalFilename", "steam_api.dll"
VALUE "ProductName", "GSE Client API" VALUE "ProductName", "GSE Client API"
VALUE "ProductVersion", "1, 0, 0, 1" VALUE "ProductVersion", "1, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }

140
resources/win/api/64/resources.rc
View file

@ -1,70 +1,70 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,33,9,23 FILEVERSION 8,33,9,23
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "InternalName", "GSE Client API (win64)" VALUE "InternalName", "GSE Client API (win64)"
VALUE "FileVersion", "08.33.09.23" VALUE "FileVersion", "08.33.09.23"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.01" VALUE "ProductVersion", "01.00.00.01"
VALUE "FileDescription", "GSE Client API" VALUE "FileDescription", "GSE Client API"
VALUE "Source Control ID", "8330923" VALUE "Source Control ID", "8330923"
VALUE "OriginalFilename", "steam_api.dll" VALUE "OriginalFilename", "steam_api.dll"
VALUE "ProductName", "GSE Client API" VALUE "ProductName", "GSE Client API"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 // language = English, sublanguage = US LANGUAGE 0x09, 0x01 // language = English, sublanguage = US
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,1 FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE Client API" VALUE "FileDescription", "GSE Client API"
VALUE "FileVersion", "1, 0, 0, 1" VALUE "FileVersion", "1, 0, 0, 1"
VALUE "InternalName", "GSE Client API" VALUE "InternalName", "GSE Client API"
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "OriginalFilename", "steam_api.dll" VALUE "OriginalFilename", "steam_api.dll"
VALUE "ProductName", "GSE Client API" VALUE "ProductName", "GSE Client API"
VALUE "ProductVersion", "1, 0, 0, 1" VALUE "ProductVersion", "1, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }

154
resources/win/client/32/resources.rc
View file

@ -1,77 +1,77 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 LANGUAGE 0, 0
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,56,38,63 FILEVERSION 8,56,38,63
PRODUCTVERSION 3,0,0,1 PRODUCTVERSION 3,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2005 GSE" VALUE "LegalCopyright", "Copyright (C) 2005 GSE"
VALUE "InternalName", "Steamclient.dll (win32)" VALUE "InternalName", "Steamclient.dll (win32)"
VALUE "FileVersion", "08.56.38.63" VALUE "FileVersion", "08.56.38.63"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "03.00.00.01" VALUE "ProductVersion", "03.00.00.01"
VALUE "FileDescription", "Steamclient.dll" VALUE "FileDescription", "Steamclient.dll"
VALUE "Source Control ID", "8563863" VALUE "Source Control ID", "8563863"
VALUE "OriginalFilename", "Steamclient.dll" VALUE "OriginalFilename", "Steamclient.dll"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 LANGUAGE 0x09, 0x01
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 3,0,0,1 FILEVERSION 3,0,0,1
PRODUCTVERSION 3,0,0,1 PRODUCTVERSION 3,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "Steamclient.dll" VALUE "FileDescription", "Steamclient.dll"
VALUE "FileVersion", "3, 0, 0, 1" VALUE "FileVersion", "3, 0, 0, 1"
VALUE "InternalName", "Steamclient.dll" VALUE "InternalName", "Steamclient.dll"
VALUE "LegalCopyright", "Copyright (C) 2005 GSE" VALUE "LegalCopyright", "Copyright (C) 2005 GSE"
VALUE "OriginalFilename", "Steamclient.dll" VALUE "OriginalFilename", "Steamclient.dll"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
VALUE "ProductVersion", "3, 0, 0, 1" VALUE "ProductVersion", "3, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 4147 // ===================================================================================== 4147
LANGUAGE 0x33, 0x04 LANGUAGE 0x33, 0x04
1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin" 1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin"

154
resources/win/client/64/resources.rc
View file

@ -1,77 +1,77 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 LANGUAGE 0, 0
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,56,38,63 FILEVERSION 8,56,38,63
PRODUCTVERSION 3,0,0,1 PRODUCTVERSION 3,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2005 GSE" VALUE "LegalCopyright", "Copyright (C) 2005 GSE"
VALUE "InternalName", "Steamclient.dll (win64)" VALUE "InternalName", "Steamclient.dll (win64)"
VALUE "FileVersion", "08.56.38.63" VALUE "FileVersion", "08.56.38.63"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "03.00.00.01" VALUE "ProductVersion", "03.00.00.01"
VALUE "FileDescription", "Steamclient.dll" VALUE "FileDescription", "Steamclient.dll"
VALUE "Source Control ID", "8563863" VALUE "Source Control ID", "8563863"
VALUE "OriginalFilename", "Steamclient.dll" VALUE "OriginalFilename", "Steamclient.dll"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 LANGUAGE 0x09, 0x01
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 3,0,0,1 FILEVERSION 3,0,0,1
PRODUCTVERSION 3,0,0,1 PRODUCTVERSION 3,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "Steamclient.dll" VALUE "FileDescription", "Steamclient.dll"
VALUE "FileVersion", "3, 0, 0, 1" VALUE "FileVersion", "3, 0, 0, 1"
VALUE "InternalName", "Steamclient.dll" VALUE "InternalName", "Steamclient.dll"
VALUE "LegalCopyright", "Copyright (C) 2005 GSE" VALUE "LegalCopyright", "Copyright (C) 2005 GSE"
VALUE "OriginalFilename", "Steamclient.dll" VALUE "OriginalFilename", "Steamclient.dll"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
VALUE "ProductVersion", "3, 0, 0, 1" VALUE "ProductVersion", "3, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 4147 // ===================================================================================== 4147
LANGUAGE 0x33, 0x04 LANGUAGE 0x33, 0x04
1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin" 1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin"

196
resources/win/file_dos_stub/file_dos_stub.cpp
View file

@ -1,98 +1,98 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <filesystem> #include <filesystem>
#include "pe_helpers/pe_helpers.hpp" #include "pe_helpers/pe_helpers.hpp"
static size_t get_file_size(std::fstream &file) static size_t get_file_size(std::fstream &file)
{ {
try try
{ {
auto org_pos = file.tellg(); auto org_pos = file.tellg();
file.seekg(0, std::ios::end); file.seekg(0, std::ios::end);
auto size = file.tellg(); auto size = file.tellg();
file.seekg(org_pos, std::ios::beg); file.seekg(org_pos, std::ios::beg);
return (size_t)size; return (size_t)size;
} }
catch(...) catch(...)
{ {
return 0; return 0;
} }
} }
static std::vector<uint8_t> load_file_partial(std::fstream &file) static std::vector<uint8_t> load_file_partial(std::fstream &file)
{ {
try try
{ {
auto org_pos = file.tellg(); auto org_pos = file.tellg();
file.seekg(0, std::ios::beg); file.seekg(0, std::ios::beg);
// 1MB is enough // 1MB is enough
std::vector<uint8_t> data(1 * 1024 * 1024, 0); std::vector<uint8_t> data(1 * 1024 * 1024, 0);
file.read((char *)&data[0], data.size()); file.read((char *)&data[0], data.size());
file.seekg(org_pos, std::ios::beg); file.seekg(org_pos, std::ios::beg);
return data; return data;
} }
catch(...) catch(...)
{ {
return std::vector<uint8_t>(); return std::vector<uint8_t>();
} }
} }
constexpr static size_t DOS_STUB_OOFSET = offsetof(IMAGE_DOS_HEADER, e_lfanew) + sizeof(IMAGE_DOS_HEADER::e_lfanew); constexpr static size_t DOS_STUB_OOFSET = offsetof(IMAGE_DOS_HEADER, e_lfanew) + sizeof(IMAGE_DOS_HEADER::e_lfanew);
constexpr static const char DOS_STUB_SIGNATURE[] = "VLV"; constexpr static const char DOS_STUB_SIGNATURE[] = "VLV";
constexpr static uint32_t DOS_STUB_ONE = 1; // what is this? constexpr static uint32_t DOS_STUB_ONE = 1; // what is this?
int main(int argc, char* *argv) int main(int argc, char* *argv)
{ {
if (argc < 2) { if (argc < 2) {
std::cerr << "Expected one or more binary files" << std::endl; std::cerr << "Expected one or more binary files" << std::endl;
return 1; return 1;
} }
for (size_t i = 1; i < (size_t)argc; ++i) { for (size_t i = 1; i < (size_t)argc; ++i) {
auto arg = argv[i]; auto arg = argv[i];
std::fstream file(std::filesystem::u8path(arg), std::ios::in | std::ios::out | std::ios::binary); std::fstream file(std::filesystem::u8path(arg), std::ios::in | std::ios::out | std::ios::binary);
if (!file.is_open()) { if (!file.is_open()) {
std::cerr << "Failed to open file: '" << arg << "'" << std::endl; std::cerr << "Failed to open file: '" << arg << "'" << std::endl;
return 1; return 1;
} }
auto file_size = get_file_size(file); auto file_size = get_file_size(file);
if (!file_size) { if (!file_size) {
std::cerr << "Failed get file size for file: '" << arg << "'" << std::endl; std::cerr << "Failed get file size for file: '" << arg << "'" << std::endl;
return 1; return 1;
} }
auto data = load_file_partial(file); auto data = load_file_partial(file);
if (data.empty()) { if (data.empty()) {
std::cerr << "Failed get file data for file: '" << arg << "'" << std::endl; std::cerr << "Failed get file data for file: '" << arg << "'" << std::endl;
return 1; return 1;
} }
uint32_t pe_size = (uint32_t)pe_helpers::get_pe_size((HMODULE)&data[0]); uint32_t pe_size = (uint32_t)pe_helpers::get_pe_size((HMODULE)&data[0]);
if (!pe_size) { if (!pe_size) {
std::cerr << "Failed get PE size for file: '" << arg << "'" << std::endl; std::cerr << "Failed get PE size for file: '" << arg << "'" << std::endl;
return 1; return 1;
} }
// std::cout << "File size = " << file_size << ", PE size = " << pe_size << std::endl; // std::cout << "File size = " << file_size << ", PE size = " << pe_size << std::endl;
file.seekp(DOS_STUB_OOFSET, std::ios::beg); file.seekp(DOS_STUB_OOFSET, std::ios::beg);
// 4 bytes: 'V' 'L' 'V' '\0' // 4 bytes: 'V' 'L' 'V' '\0'
file.write(DOS_STUB_SIGNATURE, sizeof(DOS_STUB_SIGNATURE)); file.write(DOS_STUB_SIGNATURE, sizeof(DOS_STUB_SIGNATURE));
// 4 bytes: (uint32_t)1 // 4 bytes: (uint32_t)1
file.write((const char *)&DOS_STUB_ONE, sizeof(DOS_STUB_ONE)); file.write((const char *)&DOS_STUB_ONE, sizeof(DOS_STUB_ONE));
// 4 bytes: PE image size // 4 bytes: PE image size
file.write((const char *)&pe_size, sizeof(pe_size)); file.write((const char *)&pe_size, sizeof(pe_size));
file.close(); file.close();
} }
return 0; return 0;
} }

154
resources/win/game_overlay_renderer/32/resources.rc
View file

@ -1,77 +1,77 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 LANGUAGE 0, 0
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,74,80,95 FILEVERSION 8,74,80,95
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "InternalName", "GameOverlayRenderer (win32)" VALUE "InternalName", "GameOverlayRenderer (win32)"
VALUE "FileVersion", "08.74.80.95" VALUE "FileVersion", "08.74.80.95"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.01" VALUE "ProductVersion", "01.00.00.01"
VALUE "FileDescription", "GSE Overlay Renderer" VALUE "FileDescription", "GSE Overlay Renderer"
VALUE "Source Control ID", "8748095" VALUE "Source Control ID", "8748095"
VALUE "OriginalFilename", "GameOverlayRenderer.dll" VALUE "OriginalFilename", "GameOverlayRenderer.dll"
VALUE "ProductName", "GSE Overlay Renderer" VALUE "ProductName", "GSE Overlay Renderer"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 LANGUAGE 0x09, 0x01
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,1 FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE Overlay Renderer" VALUE "FileDescription", "GSE Overlay Renderer"
VALUE "FileVersion", "1, 0, 0, 1" VALUE "FileVersion", "1, 0, 0, 1"
VALUE "InternalName", "GameOverlayRenderer" VALUE "InternalName", "GameOverlayRenderer"
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "OriginalFilename", "GameOverlayRenderer.dll" VALUE "OriginalFilename", "GameOverlayRenderer.dll"
VALUE "ProductName", "GSE Overlay Renderer" VALUE "ProductName", "GSE Overlay Renderer"
VALUE "ProductVersion", "1, 0, 0, 1" VALUE "ProductVersion", "1, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 4147 // ===================================================================================== 4147
LANGUAGE 0x33, 0x04 LANGUAGE 0x33, 0x04
1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin" 1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin"

154
resources/win/game_overlay_renderer/64/resources.rc
View file

@ -1,77 +1,77 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 LANGUAGE 0, 0
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,74,80,95 FILEVERSION 8,74,80,95
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "InternalName", "GameOverlayRenderer (win64)" VALUE "InternalName", "GameOverlayRenderer (win64)"
VALUE "FileVersion", "08.74.80.95" VALUE "FileVersion", "08.74.80.95"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.01" VALUE "ProductVersion", "01.00.00.01"
VALUE "FileDescription", "GSE Overlay Renderer" VALUE "FileDescription", "GSE Overlay Renderer"
VALUE "Source Control ID", "8748095" VALUE "Source Control ID", "8748095"
VALUE "OriginalFilename", "GameOverlayRenderer.dll" VALUE "OriginalFilename", "GameOverlayRenderer.dll"
VALUE "ProductName", "GSE Overlay Renderer" VALUE "ProductName", "GSE Overlay Renderer"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 LANGUAGE 0x09, 0x01
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,1 FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1 PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x2L // VFT_DLL FILETYPE 0x2L // VFT_DLL
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE Overlay Renderer" VALUE "FileDescription", "GSE Overlay Renderer"
VALUE "FileVersion", "1, 0, 0, 1" VALUE "FileVersion", "1, 0, 0, 1"
VALUE "InternalName", "GameOverlayRenderer" VALUE "InternalName", "GameOverlayRenderer"
VALUE "LegalCopyright", "Copyright (C) 2007" VALUE "LegalCopyright", "Copyright (C) 2007"
VALUE "OriginalFilename", "GameOverlayRenderer.dll" VALUE "OriginalFilename", "GameOverlayRenderer.dll"
VALUE "ProductName", "GSE Overlay Renderer" VALUE "ProductName", "GSE Overlay Renderer"
VALUE "ProductVersion", "1, 0, 0, 1" VALUE "ProductVersion", "1, 0, 0, 1"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 4147 // ===================================================================================== 4147
LANGUAGE 0x33, 0x04 LANGUAGE 0x33, 0x04
1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin" 1 WEVT_TEMPLATE "../WEVT_TEMPLATE1_1.bin"

140
resources/win/launcher/32/resources.rc
View file

@ -1,70 +1,70 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,56,38,63 FILEVERSION 8,56,38,63
PRODUCTVERSION 1,0,0,2 PRODUCTVERSION 1,0,0,2
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x00000001L // VFT_APP FILETYPE 0x00000001L // VFT_APP
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2021 GSE" VALUE "LegalCopyright", "Copyright (C) 2021 GSE"
VALUE "InternalName", "GSE (win32)" VALUE "InternalName", "GSE (win32)"
VALUE "FileVersion", "08.56.38.63" VALUE "FileVersion", "08.56.38.63"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.02" VALUE "ProductVersion", "01.00.00.02"
VALUE "FileDescription", "GSE" VALUE "FileDescription", "GSE"
VALUE "Source Control ID", "8563863" VALUE "Source Control ID", "8563863"
VALUE "OriginalFilename", "steam.exe" VALUE "OriginalFilename", "steam.exe"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 // language = English, sublanguage = US LANGUAGE 0x09, 0x01 // language = English, sublanguage = US
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,2 FILEVERSION 1,0,0,2
PRODUCTVERSION 1,0,0,2 PRODUCTVERSION 1,0,0,2
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x00000001L // VFT_APP FILETYPE 0x00000001L // VFT_APP
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE" VALUE "FileDescription", "GSE"
VALUE "FileVersion", "1, 0, 0, 2" VALUE "FileVersion", "1, 0, 0, 2"
VALUE "InternalName", "GSE" VALUE "InternalName", "GSE"
VALUE "LegalCopyright", "Copyright (C) 2021 GSE" VALUE "LegalCopyright", "Copyright (C) 2021 GSE"
VALUE "OriginalFilename", "steam.exe" VALUE "OriginalFilename", "steam.exe"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
VALUE "ProductVersion", "1, 0, 0, 2" VALUE "ProductVersion", "1, 0, 0, 2"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }

140
resources/win/launcher/64/resources.rc
View file

@ -1,70 +1,70 @@
// ===================================================================================== 0 // ===================================================================================== 0
LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral LANGUAGE 0, 0 // language = Neutral, sublanguage = Neutral
SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt" SOURCE_CONTROL_ID SCID "../SOURCE_CONTROL_ID.txt"
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 8,56,38,63 FILEVERSION 8,56,38,63
PRODUCTVERSION 1,0,0,2 PRODUCTVERSION 1,0,0,2
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x00000001L // VFT_APP FILETYPE 0x00000001L // VFT_APP
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "LegalCopyright", "Copyright (C) 2021 GSE" VALUE "LegalCopyright", "Copyright (C) 2021 GSE"
VALUE "InternalName", "GSE (win64)" VALUE "InternalName", "GSE (win64)"
VALUE "FileVersion", "08.56.38.63" VALUE "FileVersion", "08.56.38.63"
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "ProductVersion", "01.00.00.02" VALUE "ProductVersion", "01.00.00.02"
VALUE "FileDescription", "GSE" VALUE "FileDescription", "GSE"
VALUE "Source Control ID", "8563863" VALUE "Source Control ID", "8563863"
VALUE "OriginalFilename", "steam.exe" VALUE "OriginalFilename", "steam.exe"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }
// ===================================================================================== 1033 // ===================================================================================== 1033
LANGUAGE 0x09, 0x01 // language = English, sublanguage = US LANGUAGE 0x09, 0x01 // language = English, sublanguage = US
1 VERSIONINFO 1 VERSIONINFO
FILEVERSION 1,0,0,2 FILEVERSION 1,0,0,2
PRODUCTVERSION 1,0,0,2 PRODUCTVERSION 1,0,0,2
FILEFLAGSMASK 0x17 FILEFLAGSMASK 0x17
FILEFLAGS 0x0 FILEFLAGS 0x0
FILEOS 0x00000004L // VOS__WINDOWS32 FILEOS 0x00000004L // VOS__WINDOWS32
FILETYPE 0x00000001L // VFT_APP FILETYPE 0x00000001L // VFT_APP
FILESUBTYPE 0x0L // VFT2_UNKNOWN FILESUBTYPE 0x0L // VFT2_UNKNOWN
{ {
BLOCK "StringFileInfo" BLOCK "StringFileInfo"
{ {
BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode BLOCK "040904b0" // language code = U.S. English, character-set identifier = Unicode
{ {
VALUE "CompanyName", "GSE" VALUE "CompanyName", "GSE"
VALUE "FileDescription", "GSE" VALUE "FileDescription", "GSE"
VALUE "FileVersion", "1, 0, 0, 2" VALUE "FileVersion", "1, 0, 0, 2"
VALUE "InternalName", "GSE" VALUE "InternalName", "GSE"
VALUE "LegalCopyright", "Copyright (C) 2021 GSE" VALUE "LegalCopyright", "Copyright (C) 2021 GSE"
VALUE "OriginalFilename", "steam.exe" VALUE "OriginalFilename", "steam.exe"
VALUE "ProductName", "GSE" VALUE "ProductName", "GSE"
VALUE "ProductVersion", "1, 0, 0, 2" VALUE "ProductVersion", "1, 0, 0, 2"
} }
} }
BLOCK "VarFileInfo" BLOCK "VarFileInfo"
{ {
VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252) VALUE "Translation", 0x0409, 0x04B0 // English language (0x409) in the Windows ANSI codepage (1252)
} }
} }

2524
sdk/Readme.txt
View file

File diff suppressed because it is too large Load diff

136
sdk/steam/isteamapplist.h
View file

@ -1,69 +1,69 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to app data in Steam // Purpose: interface to app data in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMAPPLIST_H #ifndef ISTEAMAPPLIST_H
#define ISTEAMAPPLIST_H #define ISTEAMAPPLIST_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: This is a restricted interface that can only be used by previously approved apps, // Purpose: This is a restricted interface that can only be used by previously approved apps,
// contact your Steam Account Manager if you believe you need access to this API. // contact your Steam Account Manager if you believe you need access to this API.
// This interface lets you detect installed apps for the local Steam client, useful for debugging tools // This interface lets you detect installed apps for the local Steam client, useful for debugging tools
// to offer lists of apps to debug via Steam. // to offer lists of apps to debug via Steam.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamAppList class ISteamAppList
{ {
public: public:
virtual uint32 GetNumInstalledApps() = 0; virtual uint32 GetNumInstalledApps() = 0;
virtual uint32 GetInstalledApps( AppId_t *pvecAppID, uint32 unMaxAppIDs ) = 0; virtual uint32 GetInstalledApps( AppId_t *pvecAppID, uint32 unMaxAppIDs ) = 0;
virtual int GetAppName( AppId_t nAppID, STEAM_OUT_STRING() char *pchName, int cchNameMax ) = 0; // returns -1 if no name was found virtual int GetAppName( AppId_t nAppID, STEAM_OUT_STRING() char *pchName, int cchNameMax ) = 0; // returns -1 if no name was found
virtual int GetAppInstallDir( AppId_t nAppID, char *pchDirectory, int cchNameMax ) = 0; // returns -1 if no dir was found virtual int GetAppInstallDir( AppId_t nAppID, char *pchDirectory, int cchNameMax ) = 0; // returns -1 if no dir was found
virtual int GetAppBuildId( AppId_t nAppID ) = 0; // return the buildid of this app, may change at any time based on backend updates to the game virtual int GetAppBuildId( AppId_t nAppID ) = 0; // return the buildid of this app, may change at any time based on backend updates to the game
}; };
#define STEAMAPPLIST_INTERFACE_VERSION "STEAMAPPLIST_INTERFACE_VERSION001" #define STEAMAPPLIST_INTERFACE_VERSION "STEAMAPPLIST_INTERFACE_VERSION001"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamAppList *SteamAppList(); inline ISteamAppList *SteamAppList();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamAppList *, SteamAppList, STEAMAPPLIST_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamAppList *, SteamAppList, STEAMAPPLIST_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Purpose: Sent when a new app is installed (not downloaded yet) // Purpose: Sent when a new app is installed (not downloaded yet)
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 ) STEAM_CALLBACK_BEGIN( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 )
STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs
STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app is installed STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app is installed
STEAM_CALLBACK_END( 2 ) STEAM_CALLBACK_END( 2 )
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Purpose: Sent when an app is uninstalled // Purpose: Sent when an app is uninstalled
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 ) STEAM_CALLBACK_BEGIN( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 )
STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs
STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app was installed STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app was installed
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMAPPLIST_H #endif // ISTEAMAPPLIST_H

462
sdk/steam/isteamapps.h
View file

@ -1,231 +1,231 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to app data in Steam // Purpose: interface to app data in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMAPPS_H #ifndef ISTEAMAPPS_H
#define ISTEAMAPPS_H #define ISTEAMAPPS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
const int k_cubAppProofOfPurchaseKeyMax = 240; // max supported length of a legacy cd key const int k_cubAppProofOfPurchaseKeyMax = 240; // max supported length of a legacy cd key
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: interface to app data // Purpose: interface to app data
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamApps class ISteamApps
{ {
public: public:
virtual bool BIsSubscribed() = 0; virtual bool BIsSubscribed() = 0;
virtual bool BIsLowViolence() = 0; virtual bool BIsLowViolence() = 0;
virtual bool BIsCybercafe() = 0; virtual bool BIsCybercafe() = 0;
virtual bool BIsVACBanned() = 0; virtual bool BIsVACBanned() = 0;
virtual const char *GetCurrentGameLanguage() = 0; virtual const char *GetCurrentGameLanguage() = 0;
virtual const char *GetAvailableGameLanguages() = 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 // 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; virtual bool BIsSubscribedApp( AppId_t appID ) = 0;
// Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed // Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed
virtual bool BIsDlcInstalled( AppId_t appID ) = 0; virtual bool BIsDlcInstalled( AppId_t appID ) = 0;
// returns the Unix time of the purchase of the app // returns the Unix time of the purchase of the app
virtual uint32 GetEarliestPurchaseUnixTime( AppId_t nAppID ) = 0; virtual uint32 GetEarliestPurchaseUnixTime( AppId_t nAppID ) = 0;
// Checks if the user is subscribed to the current app through a free weekend // 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 // 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 weekend // Before using, please ask your Valve technical contact how to package and secure your free weekend
virtual bool BIsSubscribedFromFreeWeekend() = 0; virtual bool BIsSubscribedFromFreeWeekend() = 0;
// Returns the number of DLC pieces for the running app // Returns the number of DLC pieces for the running app
virtual int GetDLCCount() = 0; virtual int GetDLCCount() = 0;
// Returns metadata for DLC by index, of range [0, GetDLCCount()] // 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; virtual bool BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize ) = 0;
// Install/Uninstall control for optional DLC // Install/Uninstall control for optional DLC
virtual void InstallDLC( AppId_t nAppID ) = 0; virtual void InstallDLC( AppId_t nAppID ) = 0;
virtual void UninstallDLC( 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 // 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 // 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. // to users when they purchase the game, before the game ships.
// You'll receive an AppProofOfPurchaseKeyResponse_t callback when // You'll receive an AppProofOfPurchaseKeyResponse_t callback when
// the key is available (which may be immediately). // the key is available (which may be immediately).
virtual void RequestAppProofOfPurchaseKey( AppId_t nAppID ) = 0; 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 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 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 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 // returns current app install folder for AppID, returns folder name length
virtual uint32 GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize ) = 0; 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) 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(), // 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 // the user has a temporary license borrowed via Family Sharing
virtual CSteamID GetAppOwner() = 0; virtual CSteamID GetAppOwner() = 0;
// Returns the associated launch param if the game is run via steam://run/<appid>//?param1=value1&param2=value2&param3=value3 etc. // Returns the associated launch param if the game is run via steam://run/<appid>//?param1=value1&param2=value2&param3=value3 etc.
// Parameter names starting with the character '@' are reserved for internal use and will always return and empty string. // 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, // 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. // 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 // Check for new launch parameters on callback NewUrlLaunchParameters_t
virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0; virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0;
// get download progress for optional DLC // get download progress for optional DLC
virtual bool GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0; 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 // return the buildid of this app, may change at any time based on backend updates to the game
virtual int GetAppBuildId() = 0; virtual int GetAppBuildId() = 0;
// Request all proof of purchase keys for the calling appid and associated DLC. // Request all proof of purchase keys for the calling appid and associated DLC.
// A series of AppProofOfPurchaseKeyResponse_t callbacks will be sent with // A series of AppProofOfPurchaseKeyResponse_t callbacks will be sent with
// appropriate appid values, ending with a final callback where the m_nAppId // appropriate appid values, ending with a final callback where the m_nAppId
// member is k_uAppIdInvalid (zero). // member is k_uAppIdInvalid (zero).
virtual void RequestAllProofOfPurchaseKeys() = 0; virtual void RequestAllProofOfPurchaseKeys() = 0;
STEAM_CALL_RESULT( FileDetailsResult_t ) STEAM_CALL_RESULT( FileDetailsResult_t )
virtual SteamAPICall_t GetFileDetails( const char* pszFileName ) = 0; virtual SteamAPICall_t GetFileDetails( const char* pszFileName ) = 0;
// Get command line if game was launched via Steam URL, e.g. steam://run/<appid>//<command line>/. // Get command line if game was launched via Steam URL, e.g. steam://run/<appid>//<command line>/.
// This method of passing a connect string (used when joining via rich presence, accepting an // 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 // 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 // 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 // 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. // configuration on Steam. Ask Valve for help with this.
// //
// If game was already running and launched again, the NewUrlLaunchParameters_t will be fired. // If game was already running and launched again, the NewUrlLaunchParameters_t will be fired.
virtual int GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine ) = 0; 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 // Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID
virtual bool BIsSubscribedFromFamilySharing() = 0; virtual bool BIsSubscribedFromFamilySharing() = 0;
// check if game is a timed trial with limited playtime // check if game is a timed trial with limited playtime
virtual bool BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed ) = 0; 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 // 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; virtual bool SetDlcContext( AppId_t nAppID ) = 0;
// returns total number of known app beta branches (including default "public" branch ) // returns total number of known app beta branches (including default "public" branch )
virtual int GetNumBetas( int *pnAvailable, int *pnPrivate ) = 0; // virtual int GetNumBetas( int *pnAvailable, int *pnPrivate ) = 0; //
// return beta branch details, name, description, current BuildID and state flags (EBetaBranchFlags) // 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 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 // 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; virtual bool SetActiveBeta( const char *pchBetaName ) = 0;
}; };
#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION008" #define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION008"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamApps *SteamApps(); inline ISteamApps *SteamApps();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamApps *, SteamApps, STEAMAPPS_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamApps *, SteamApps, STEAMAPPS_INTERFACE_VERSION );
// Global accessor for the gameserver client // Global accessor for the gameserver client
inline ISteamApps *SteamGameServerApps(); inline ISteamApps *SteamGameServerApps();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamApps *, SteamGameServerApps, STEAMAPPS_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamApps *, SteamGameServerApps, STEAMAPPS_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: posted after the user gains ownership of DLC & that DLC is installed // Purpose: posted after the user gains ownership of DLC & that DLC is installed
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct DlcInstalled_t struct DlcInstalled_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 5 }; enum { k_iCallback = k_iSteamAppsCallbacks + 5 };
AppId_t m_nAppID; // AppID of the DLC AppId_t m_nAppID; // AppID of the DLC
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: possible results when registering an activation code // Purpose: possible results when registering an activation code
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum ERegisterActivationCodeResult enum ERegisterActivationCodeResult
{ {
k_ERegisterActivationCodeResultOK = 0, k_ERegisterActivationCodeResultOK = 0,
k_ERegisterActivationCodeResultFail = 1, k_ERegisterActivationCodeResultFail = 1,
k_ERegisterActivationCodeResultAlreadyRegistered = 2, k_ERegisterActivationCodeResultAlreadyRegistered = 2,
k_ERegisterActivationCodeResultTimeout = 3, k_ERegisterActivationCodeResultTimeout = 3,
k_ERegisterActivationCodeAlreadyOwned = 4, k_ERegisterActivationCodeAlreadyOwned = 4,
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: response to RegisterActivationCode() // Purpose: response to RegisterActivationCode()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct RegisterActivationCodeResponse_t struct RegisterActivationCodeResponse_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 8 }; enum { k_iCallback = k_iSteamAppsCallbacks + 8 };
ERegisterActivationCodeResult m_eResult; ERegisterActivationCodeResult m_eResult;
uint32 m_unPackageRegistered; // package that was registered. Only set on success uint32 m_unPackageRegistered; // package that was registered. Only set on success
}; };
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// Purpose: posted after the user gains executes a Steam URL with command line or query parameters // Purpose: posted after the user gains executes a Steam URL with command line or query parameters
// such as steam://run/<appid>//-commandline/?param1=value1&param2=value2&param3=value3 etc // such as steam://run/<appid>//-commandline/?param1=value1&param2=value2&param3=value3 etc
// while the game is already running. The new params can be queried // while the game is already running. The new params can be queried
// with GetLaunchQueryParam and GetLaunchCommandLine // with GetLaunchQueryParam and GetLaunchCommandLine
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
struct NewUrlLaunchParameters_t struct NewUrlLaunchParameters_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 14 }; enum { k_iCallback = k_iSteamAppsCallbacks + 14 };
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys // Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys
// for supporting third-party CD keys, or other proof-of-purchase systems. // for supporting third-party CD keys, or other proof-of-purchase systems.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct AppProofOfPurchaseKeyResponse_t struct AppProofOfPurchaseKeyResponse_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 21 }; enum { k_iCallback = k_iSteamAppsCallbacks + 21 };
EResult m_eResult; EResult m_eResult;
uint32 m_nAppID; uint32 m_nAppID;
uint32 m_cchKeyLength; uint32 m_cchKeyLength;
char m_rgchKey[k_cubAppProofOfPurchaseKeyMax]; char m_rgchKey[k_cubAppProofOfPurchaseKeyMax];
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: response to GetFileDetails // Purpose: response to GetFileDetails
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct FileDetailsResult_t struct FileDetailsResult_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 23 }; enum { k_iCallback = k_iSteamAppsCallbacks + 23 };
EResult m_eResult; EResult m_eResult;
uint64 m_ulFileSize; // original file size in bytes uint64 m_ulFileSize; // original file size in bytes
uint8 m_FileSHA[20]; // original file SHA1 hash uint8 m_FileSHA[20]; // original file SHA1 hash
uint32 m_unFlags; // uint32 m_unFlags; //
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called for games in Timed Trial mode // Purpose: called for games in Timed Trial mode
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct TimedTrialStatus_t struct TimedTrialStatus_t
{ {
enum { k_iCallback = k_iSteamAppsCallbacks + 30 }; enum { k_iCallback = k_iSteamAppsCallbacks + 30 };
AppId_t m_unAppID; // appID AppId_t m_unAppID; // appID
bool m_bIsOffline; // if true, time allowed / played refers to offline time, not total time 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_unSecondsAllowed; // how many seconds the app can be played in total
uint32 m_unSecondsPlayed; // how many seconds the app was already played uint32 m_unSecondsPlayed; // how many seconds the app was already played
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMAPPS_H #endif // ISTEAMAPPS_H

56
sdk/steam/isteamappticket.h
View file

@ -1,28 +1,28 @@
//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: a private, but well versioned, interface to get at critical bits // 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 // of a steam3 appticket - consumed by the simple drm wrapper to let it
// ask about ownership with greater confidence. // ask about ownership with greater confidence.
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMAPPTICKET_H #ifndef ISTEAMAPPTICKET_H
#define ISTEAMAPPTICKET_H #define ISTEAMAPPTICKET_H
#pragma once #pragma once
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: hand out a reasonable "future proof" view of an app ownership ticket // 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 // 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 // steamid are located. the sizes of the appid and steamid are implicit in
// (each version of) the interface - currently uin32 appid and uint64 steamid // (each version of) the interface - currently uin32 appid and uint64 steamid
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamAppTicket class ISteamAppTicket
{ {
public: public:
virtual uint32 GetAppOwnershipTicketData( uint32 nAppID, void *pvBuffer, uint32 cbBufferLength, uint32 *piAppId, uint32 *piSteamId, uint32 *piSignature, uint32 *pcbSignature ) = 0; 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" #define STEAMAPPTICKET_INTERFACE_VERSION "STEAMAPPTICKET_INTERFACE_VERSION001"
#endif // ISTEAMAPPTICKET_H #endif // ISTEAMAPPTICKET_H

346
sdk/steam/isteamclient.h
View file

@ -1,173 +1,173 @@
//====== Copyright Valve Corporation, All rights reserved. ==================== //====== Copyright Valve Corporation, All rights reserved. ====================
// //
// Internal low-level access to Steamworks interfaces. // Internal low-level access to Steamworks interfaces.
// //
// Most users of the Steamworks SDK do not need to include this file. // Most users of the Steamworks SDK do not need to include this file.
// You should only include this if you are doing something special. // You should only include this if you are doing something special.
//============================================================================= //=============================================================================
#ifndef ISTEAMCLIENT_H #ifndef ISTEAMCLIENT_H
#define ISTEAMCLIENT_H #define ISTEAMCLIENT_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Interface to creating a new steam instance, or to // Purpose: Interface to creating a new steam instance, or to
// connect to an existing steam instance, whether it's in a // connect to an existing steam instance, whether it's in a
// different process or is local. // different process or is local.
// //
// For most scenarios this is all handled automatically via SteamAPI_Init(). // 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, // 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 // or if you want to implement a multiplexed gameserver where a single process
// is handling multiple games at once with independent gameserver SteamIDs. // is handling multiple games at once with independent gameserver SteamIDs.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamClient class ISteamClient
{ {
public: public:
// Creates a communication pipe to the Steam client. // Creates a communication pipe to the Steam client.
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamPipe CreateSteamPipe() = 0; virtual HSteamPipe CreateSteamPipe() = 0;
// Releases a previously created communications pipe // Releases a previously created communications pipe
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0; virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
// connects to an existing global user, failing if none exists // connects to an existing global user, failing if none exists
// used by the game to coordinate with the steamUI // used by the game to coordinate with the steamUI
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0; virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
// used by game servers, create a steam user that won't be shared with anyone else // 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 // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0; virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0;
// removes an allocated user // removes an allocated user
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0; virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
// retrieves the ISteamUser interface associated with the handle // retrieves the ISteamUser interface associated with the handle
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// retrieves the ISteamGameServer interface associated with the handle // retrieves the ISteamGameServer interface associated with the handle
virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// set the local IP and Port to bind to // set the local IP and Port to bind to
// this must be set before CreateLocalUser() // this must be set before CreateLocalUser()
virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0; virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0;
// returns the ISteamFriends interface // returns the ISteamFriends interface
virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamUtils interface // returns the ISteamUtils interface
virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamMatchmaking interface // returns the ISteamMatchmaking interface
virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamMatchmakingServers interface // returns the ISteamMatchmakingServers interface
virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the a generic interface // returns the a generic interface
virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamUserStats interface // returns the ISteamUserStats interface
virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamGameServerStats interface // returns the ISteamGameServerStats interface
virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns apps interface // returns apps interface
virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// networking // networking
virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// remote storage // remote storage
virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// user screenshots // user screenshots
virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// game search // game search
virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead. // Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead.
STEAM_PRIVATE_API( virtual void RunFrame() = 0; ) STEAM_PRIVATE_API( virtual void RunFrame() = 0; )
// returns the number of IPC calls made since the last time this function was called // 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 // 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 // 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. // control how often you do them.
virtual uint32 GetIPCCallCount() = 0; virtual uint32 GetIPCCallCount() = 0;
// API warning handling // API warning handling
// 'int' is the severity; 0 for msg, 1 for warning // 'int' is the severity; 0 for msg, 1 for warning
// 'const char *' is the text of the message // 'const char *' is the text of the message
// callbacks will occur directly after the API function is called that generated the warning or message. // callbacks will occur directly after the API function is called that generated the warning or message.
virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0; virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0;
// Trigger global shutdown for the DLL // Trigger global shutdown for the DLL
virtual bool BShutdownIfAllPipesClosed() = 0; virtual bool BShutdownIfAllPipesClosed() = 0;
// Expose HTTP interface // Expose HTTP interface
virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Exposes the ISteamController interface - deprecated in favor of Steam Input // Exposes the ISteamController interface - deprecated in favor of Steam Input
virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Exposes the ISteamUGC interface // Exposes the ISteamUGC interface
virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Music Player // Music Player
virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Music Player Remote // Music Player Remote
virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
// html page display // html page display
virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
// Helper functions for internal Steam usage // Helper functions for internal Steam usage
STEAM_PRIVATE_API( virtual void DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; ) 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 DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; )
STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; ) STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; )
// inventory // inventory
virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Video // Video
virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Parental controls // Parental controls
virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Exposes the Steam Input interface for controller support // Exposes the Steam Input interface for controller support
virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Steam Parties interface // Steam Parties interface
virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Steam Remote Play interface // Steam Remote Play interface
virtual ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; ) STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; )
}; };
#define STEAMCLIENT_INTERFACE_VERSION "SteamClient021" #define STEAMCLIENT_INTERFACE_VERSION "SteamClient021"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global ISteamClient interface accessor // Global ISteamClient interface accessor
inline ISteamClient *SteamClient(); inline ISteamClient *SteamClient();
STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamClient *, SteamClient, SteamInternal_CreateInterface( STEAMCLIENT_INTERFACE_VERSION ), "global", STEAMCLIENT_INTERFACE_VERSION ); STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamClient *, SteamClient, SteamInternal_CreateInterface( STEAMCLIENT_INTERFACE_VERSION ), "global", STEAMCLIENT_INTERFACE_VERSION );
// The internal ISteamClient used for the gameserver interface. // 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.) // (This is actually the same thing. You really shouldn't need to access any of this stuff directly.)
inline ISteamClient *SteamGameServerClient() { return SteamClient(); } inline ISteamClient *SteamGameServerClient() { return SteamClient(); }
#endif #endif
#endif // ISTEAMCLIENT_H #endif // ISTEAMCLIENT_H

292
sdk/steam/isteamclient020.h
View file

@ -1,146 +1,146 @@
#ifndef ISTEAMCLIENT020_H #ifndef ISTEAMCLIENT020_H
#define ISTEAMCLIENT020_H #define ISTEAMCLIENT020_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
class ISteamClient020 class ISteamClient020
{ {
public: public:
// Creates a communication pipe to the Steam client. // Creates a communication pipe to the Steam client.
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamPipe CreateSteamPipe() = 0; virtual HSteamPipe CreateSteamPipe() = 0;
// Releases a previously created communications pipe // Releases a previously created communications pipe
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0; virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
// connects to an existing global user, failing if none exists // connects to an existing global user, failing if none exists
// used by the game to coordinate with the steamUI // used by the game to coordinate with the steamUI
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0; virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
// used by game servers, create a steam user that won't be shared with anyone else // 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 // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0; virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0;
// removes an allocated user // removes an allocated user
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0; virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
// retrieves the ISteamUser interface associated with the handle // retrieves the ISteamUser interface associated with the handle
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// retrieves the ISteamGameServer interface associated with the handle // retrieves the ISteamGameServer interface associated with the handle
virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// set the local IP and Port to bind to // set the local IP and Port to bind to
// this must be set before CreateLocalUser() // this must be set before CreateLocalUser()
virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0; virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0;
// returns the ISteamFriends interface // returns the ISteamFriends interface
virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamUtils interface // returns the ISteamUtils interface
virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamMatchmaking interface // returns the ISteamMatchmaking interface
virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamMatchmakingServers interface // returns the ISteamMatchmakingServers interface
virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the a generic interface // returns the a generic interface
virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamUserStats interface // returns the ISteamUserStats interface
virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns the ISteamGameServerStats interface // returns the ISteamGameServerStats interface
virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns apps interface // returns apps interface
virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// networking // networking
virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// remote storage // remote storage
virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// user screenshots // user screenshots
virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// game search // game search
virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead. // Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead.
STEAM_PRIVATE_API( virtual void RunFrame() = 0; ) STEAM_PRIVATE_API( virtual void RunFrame() = 0; )
// returns the number of IPC calls made since the last time this function was called // 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 // 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 // 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. // control how often you do them.
virtual uint32 GetIPCCallCount() = 0; virtual uint32 GetIPCCallCount() = 0;
// API warning handling // API warning handling
// 'int' is the severity; 0 for msg, 1 for warning // 'int' is the severity; 0 for msg, 1 for warning
// 'const char *' is the text of the message // 'const char *' is the text of the message
// callbacks will occur directly after the API function is called that generated the warning or message. // callbacks will occur directly after the API function is called that generated the warning or message.
virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0; virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0;
// Trigger global shutdown for the DLL // Trigger global shutdown for the DLL
virtual bool BShutdownIfAllPipesClosed() = 0; virtual bool BShutdownIfAllPipesClosed() = 0;
// Expose HTTP interface // Expose HTTP interface
virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Deprecated - the ISteamUnifiedMessages interface is no longer intended for public consumption. // Deprecated - the ISteamUnifiedMessages interface is no longer intended for public consumption.
STEAM_PRIVATE_API( virtual void *DEPRECATED_GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0 ; ) STEAM_PRIVATE_API( virtual void *DEPRECATED_GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0 ; )
// Exposes the ISteamController interface - deprecated in favor of Steam Input // Exposes the ISteamController interface - deprecated in favor of Steam Input
virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Exposes the ISteamUGC interface // Exposes the ISteamUGC interface
virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// returns app list interface, only available on specially registered apps // returns app list interface, only available on specially registered apps
virtual ISteamAppList *GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamAppList *GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Music Player // Music Player
virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Music Player Remote // Music Player Remote
virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
// html page display // html page display
virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0; virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
// Helper functions for internal Steam usage // Helper functions for internal Steam usage
STEAM_PRIVATE_API( virtual void DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; ) 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 DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; )
STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; ) STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; )
// inventory // inventory
virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Video // Video
virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Parental controls // Parental controls
virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Exposes the Steam Input interface for controller support // Exposes the Steam Input interface for controller support
virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Steam Parties interface // Steam Parties interface
virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
// Steam Remote Play interface // Steam Remote Play interface
virtual ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0; virtual ISteamRemotePlay *GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; ) STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; )
}; };
#endif // ISTEAMCLIENT020_H #endif // ISTEAMCLIENT020_H

1554
sdk/steam/isteamcontroller.h
View file

File diff suppressed because it is too large Load diff

1506
sdk/steam/isteamfriends.h
View file

File diff suppressed because it is too large Load diff

146
sdk/steam/isteamgamecoordinator.h
View file

@ -1,76 +1,76 @@
//====== Copyright ©, Valve Corporation, All rights reserved. ======= //====== Copyright ©, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to the game coordinator for this application // Purpose: interface to the game coordinator for this application
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMGAMECOORDINATOR #ifndef ISTEAMGAMECOORDINATOR
#define ISTEAMGAMECOORDINATOR #define ISTEAMGAMECOORDINATOR
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// list of possible return values from the ISteamGameCoordinator API // list of possible return values from the ISteamGameCoordinator API
enum EGCResults enum EGCResults
{ {
k_EGCResultOK = 0, k_EGCResultOK = 0,
k_EGCResultNoMessage = 1, // There is no message in the queue k_EGCResultNoMessage = 1, // There is no message in the queue
k_EGCResultBufferTooSmall = 2, // The buffer is too small for the requested message k_EGCResultBufferTooSmall = 2, // The buffer is too small for the requested message
k_EGCResultNotLoggedOn = 3, // The client is not logged onto Steam k_EGCResultNotLoggedOn = 3, // The client is not logged onto Steam
k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for sending and receiving messages from the Game Coordinator // Purpose: Functions for sending and receiving messages from the Game Coordinator
// for this application // for this application
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamGameCoordinator class ISteamGameCoordinator
{ {
public: public:
// sends a message to the Game Coordinator // sends a message to the Game Coordinator
// Note this underscore isn't a mistake, on MSVC SendMessage is a function defined in WinUser.h // Note this underscore isn't a mistake, on MSVC SendMessage is a function defined in WinUser.h
// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage
virtual EGCResults SendMessage_( uint32 unMsgType, const void *pubData, uint32 cubData ) = 0; virtual EGCResults SendMessage_( uint32 unMsgType, const void *pubData, uint32 cubData ) = 0;
// returns true if there is a message waiting from the game coordinator // returns true if there is a message waiting from the game coordinator
virtual bool IsMessageAvailable( uint32 *pcubMsgSize ) = 0; virtual bool IsMessageAvailable( uint32 *pcubMsgSize ) = 0;
// fills the provided buffer with the first message in the queue and returns k_EGCResultOK or // 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. // 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 // 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. // and the message remains at the head of the queue.
virtual EGCResults RetrieveMessage( uint32 *punMsgType, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0; virtual EGCResults RetrieveMessage( uint32 *punMsgType, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0;
}; };
#define STEAMGAMECOORDINATOR_INTERFACE_VERSION "SteamGameCoordinator001" #define STEAMGAMECOORDINATOR_INTERFACE_VERSION "SteamGameCoordinator001"
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
// callback notification - A new message is available for reading from the message queue // callback notification - A new message is available for reading from the message queue
struct GCMessageAvailable_t struct GCMessageAvailable_t
{ {
enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 1 }; enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 1 };
uint32 m_nMessageSize; uint32 m_nMessageSize;
}; };
// callback notification - A message failed to make it to the GC. It may be down temporarily // callback notification - A message failed to make it to the GC. It may be down temporarily
struct GCMessageFailed_t struct GCMessageFailed_t
{ {
enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 2 }; enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 2 };
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMGAMECOORDINATOR #endif // ISTEAMGAMECOORDINATOR

822
sdk/steam/isteamgameserver.h
View file

@ -1,411 +1,411 @@
//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to steam for game servers // Purpose: interface to steam for game servers
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMGAMESERVER_H #ifndef ISTEAMGAMESERVER_H
#define ISTEAMGAMESERVER_H #define ISTEAMGAMESERVER_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for authenticating users via Steam to play on a game server // Purpose: Functions for authenticating users via Steam to play on a game server
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamGameServer class ISteamGameServer
{ {
public: public:
// //
// Basic server data. These properties, if set, must be set before before calling LogOn. They // Basic server data. These properties, if set, must be set before before calling LogOn. They
// may not be changed after logged in. // may not be changed after logged in.
// //
/// This is called by SteamGameServer_Init, and you will usually not need to call it directly /// 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; ) 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. /// 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. /// 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; 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. /// 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. /// 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; 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 /// 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. /// this application is the original game, not a mod.
/// ///
/// @see k_cbMaxGameServerGameDir /// @see k_cbMaxGameServerGameDir
virtual void SetModDir( const char *pszModDir ) = 0; virtual void SetModDir( const char *pszModDir ) = 0;
/// Is this is a dedicated server? The default value is false. /// Is this is a dedicated server? The default value is false.
virtual void SetDedicatedServer( bool bDedicated ) = 0; virtual void SetDedicatedServer( bool bDedicated ) = 0;
// //
// Login // Login
// //
/// Begin process to login to a persistent game server account /// Begin process to login to a persistent game server account
/// ///
/// You need to register for callbacks to determine the result of this operation. /// You need to register for callbacks to determine the result of this operation.
/// @see SteamServersConnected_t /// @see SteamServersConnected_t
/// @see SteamServerConnectFailure_t /// @see SteamServerConnectFailure_t
/// @see SteamServersDisconnected_t /// @see SteamServersDisconnected_t
virtual void LogOn( const char *pszToken ) = 0; virtual void LogOn( const char *pszToken ) = 0;
/// Login to a generic, anonymous account. /// Login to a generic, anonymous account.
/// ///
/// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init, /// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
/// but this is no longer the case. /// but this is no longer the case.
virtual void LogOnAnonymous() = 0; virtual void LogOnAnonymous() = 0;
/// Begin process of logging game server out of steam /// Begin process of logging game server out of steam
virtual void LogOff() = 0; virtual void LogOff() = 0;
// status functions // status functions
virtual bool BLoggedOn() = 0; virtual bool BLoggedOn() = 0;
virtual bool BSecure() = 0; virtual bool BSecure() = 0;
virtual CSteamID GetSteamID() = 0; virtual CSteamID GetSteamID() = 0;
/// Returns true if the master server has requested a restart. /// Returns true if the master server has requested a restart.
/// Only returns true once per request. /// Only returns true once per request.
virtual bool WasRestartRequested() = 0; virtual bool WasRestartRequested() = 0;
// //
// Server state. These properties may be changed at any time. // Server state. These properties may be changed at any time.
// //
/// Max player count that will be reported to server browser and client queries /// Max player count that will be reported to server browser and client queries
virtual void SetMaxPlayerCount( int cPlayersMax ) = 0; virtual void SetMaxPlayerCount( int cPlayersMax ) = 0;
/// Number of bots. Default value is zero /// Number of bots. Default value is zero
virtual void SetBotPlayerCount( int cBotplayers ) = 0; virtual void SetBotPlayerCount( int cBotplayers ) = 0;
/// Set the name of server as it will appear in the server browser /// Set the name of server as it will appear in the server browser
/// ///
/// @see k_cbMaxGameServerName /// @see k_cbMaxGameServerName
virtual void SetServerName( const char *pszServerName ) = 0; virtual void SetServerName( const char *pszServerName ) = 0;
/// Set name of map to report in the server browser /// Set name of map to report in the server browser
/// ///
/// @see k_cbMaxGameServerMapName /// @see k_cbMaxGameServerMapName
virtual void SetMapName( const char *pszMapName ) = 0; virtual void SetMapName( const char *pszMapName ) = 0;
/// Let people know if your server will require a password /// Let people know if your server will require a password
virtual void SetPasswordProtected( bool bPasswordProtected ) = 0; virtual void SetPasswordProtected( bool bPasswordProtected ) = 0;
/// Spectator server port to advertise. The default value is zero, meaning the /// 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, /// 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 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. /// 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 /// 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 /// 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. /// 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 /// 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 /// configure the server to actually listen on this port and handle any spectator traffic
virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0; virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0;
/// Name of the spectator server. (Only used if spectator port is nonzero.) /// Name of the spectator server. (Only used if spectator port is nonzero.)
/// ///
/// @see k_cbMaxGameServerMapName /// @see k_cbMaxGameServerMapName
virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0; virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0;
/// Call this to clear the whole list of key/values that are sent in rules queries. /// Call this to clear the whole list of key/values that are sent in rules queries.
virtual void ClearAllKeyValues() = 0; virtual void ClearAllKeyValues() = 0;
/// Call this to add/update a key/value pair. /// Call this to add/update a key/value pair.
virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0; 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 /// 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 /// it allows users to filter in the matchmaking/server-browser interfaces based on the value
/// ///
/// @see k_cbMaxGameServerTags /// @see k_cbMaxGameServerTags
virtual void SetGameTags( const char *pchGameTags ) = 0; virtual void SetGameTags( const char *pchGameTags ) = 0;
/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set /// 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 /// it allows users to filter in the matchmaking/server-browser interfaces based on the value
/// ///
/// @see k_cbMaxGameServerGameData /// @see k_cbMaxGameServerGameData
virtual void SetGameData( const char *pchGameData ) = 0; virtual void SetGameData( const char *pchGameData ) = 0;
/// Region identifier. This is an optional field, the default value is empty, meaning the "world" region /// Region identifier. This is an optional field, the default value is empty, meaning the "world" region
virtual void SetRegion( const char *pszRegion ) = 0; virtual void SetRegion( const char *pszRegion ) = 0;
/// Indicate whether you wish to be listed on the master server list /// Indicate whether you wish to be listed on the master server list
/// and/or respond to server browser / LAN discovery packets. /// and/or respond to server browser / LAN discovery packets.
/// The server starts with this value set to false. You should set all /// The server starts with this value set to false. You should set all
/// relevant server parameters before enabling advertisement on the server. /// relevant server parameters before enabling advertisement on the server.
/// ///
/// (This function used to be named EnableHeartbeats, so if you are wondering /// (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, /// where that function went, it's right here. It does the same thing as before,
/// the old name was just confusing.) /// the old name was just confusing.)
virtual void SetAdvertiseServerActive( bool bActive ) = 0; virtual void SetAdvertiseServerActive( bool bActive ) = 0;
// //
// Player list management / authentication. // Player list management / authentication.
// //
// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). // Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ).
// pcbTicket retrieves the length of the actual ticket. // 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 // 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 // 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; 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 // 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 ) // 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; 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 // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
virtual void EndAuthSession( CSteamID steamID ) = 0; 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 // 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; virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
// After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function // 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. // to determine if the user owns downloadable content specified by the provided AppID.
virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0; virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
// Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t // 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 // returns false if we're not connected to the steam servers and thus cannot ask
virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0; virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0;
// these two functions s are deprecated, and will not return results // these two functions s are deprecated, and will not return results
// they will be removed in a future version of the SDK // they will be removed in a future version of the SDK
virtual void GetGameplayStats( ) = 0; virtual void GetGameplayStats( ) = 0;
STEAM_CALL_RESULT( GSReputation_t ) STEAM_CALL_RESULT( GSReputation_t )
virtual SteamAPICall_t GetServerReputation() = 0; virtual SteamAPICall_t GetServerReputation() = 0;
// Returns the public IP of the server according to Steam, useful when the server is // 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 // behind NAT and you want to advertise its IP in a lobby for other clients to directly
// connect to // connect to
virtual SteamIPAddress_t GetPublicIP() = 0; virtual SteamIPAddress_t GetPublicIP() = 0;
// Server browser related query packet processing for shared socket mode. These are used // 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. // 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 // 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 // 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. // 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 // 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. // don't have to open up more ports on their firewalls.
// Call this when a packet that starts with 0xFFFFFFFF comes in. That means // Call this when a packet that starts with 0xFFFFFFFF comes in. That means
// it's for us. // it's for us.
virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0; 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. // 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. // 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. // 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. // Call this each frame until it returns 0.
virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0; virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;
// //
// Server clan association // Server clan association
// //
// associate this game server with this clan for the purposes of computing player compat // associate this game server with this clan for the purposes of computing player compat
STEAM_CALL_RESULT( AssociateWithClanResult_t ) STEAM_CALL_RESULT( AssociateWithClanResult_t )
virtual SteamAPICall_t AssociateWithClan( CSteamID steamIDClan ) = 0; 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 // ask if any of the current players dont want to play with this new player - or vice versa
STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t ) STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t )
virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0; virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0;
// Handles receiving a new connection from a Steam user. This call will ask the Steam // 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 // 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 // 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 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. // 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 // 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 // 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) // 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. // DEPRECATED! This function will be removed from the SDK in an upcoming version.
// Please migrate to BeginAuthSession and related functions. // Please migrate to BeginAuthSession and related functions.
//virtual bool SendUserConnectAndAuthenticate_DEPRECATED( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0; //virtual bool SendUserConnectAndAuthenticate_DEPRECATED( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;
virtual bool SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0; virtual bool SendUserConnectAndAuthenticate( 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. // 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() // 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. // when this user leaves the server just like you would for a real user.
virtual CSteamID CreateUnauthenticatedUserConnection() = 0; virtual CSteamID CreateUnauthenticatedUserConnection() = 0;
// Should be called whenever a user leaves our game server, this lets Steam internally // 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 // 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. // 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. // DEPRECATED! This function will be removed from the SDK in an upcoming version.
// Please migrate to BeginAuthSession and related functions. // Please migrate to BeginAuthSession and related functions.
//virtual void SendUserDisconnect_DEPRECATED( CSteamID steamIDUser ) = 0; //virtual void SendUserDisconnect_DEPRECATED( CSteamID steamIDUser ) = 0;
virtual void SendUserDisconnect( CSteamID steamIDUser ) = 0; virtual void SendUserDisconnect( CSteamID steamIDUser ) = 0;
// Update the data to be displayed in the server browser and matchmaking interfaces for a user // 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 // currently connected to the server. For regular users you must call this after you receive a
// GSUserValidationSuccess callback. // GSUserValidationSuccess callback.
// //
// Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player) // 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; virtual bool BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) = 0;
// Deprecated functions. These will be removed in a future version of the SDK. // 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 // If you really need these, please contact us and help us understand what you are
// using them for. // using them for.
STEAM_PRIVATE_API( STEAM_PRIVATE_API(
virtual void SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) = 0; virtual void SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) = 0;
virtual void ForceMasterServerHeartbeat_DEPRECATED() = 0; virtual void ForceMasterServerHeartbeat_DEPRECATED() = 0;
) )
}; };
#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer015" #define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer015"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global accessor // Global accessor
inline ISteamGameServer *SteamGameServer(); inline ISteamGameServer *SteamGameServer();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServer *, SteamGameServer, STEAMGAMESERVER_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServer *, SteamGameServer, STEAMGAMESERVER_INTERFACE_VERSION );
#endif #endif
// game server flags // game server flags
const uint32 k_unServerFlagNone = 0x00; const uint32 k_unServerFlagNone = 0x00;
const uint32 k_unServerFlagActive = 0x01; // server has users playing const uint32 k_unServerFlagActive = 0x01; // server has users playing
const uint32 k_unServerFlagSecure = 0x02; // server wants to be secure const uint32 k_unServerFlagSecure = 0x02; // server wants to be secure
const uint32 k_unServerFlagDedicated = 0x04; // server is dedicated const uint32 k_unServerFlagDedicated = 0x04; // server is dedicated
const uint32 k_unServerFlagLinux = 0x08; // linux build const uint32 k_unServerFlagLinux = 0x08; // linux build
const uint32 k_unServerFlagPassworded = 0x10; // password protected const uint32 k_unServerFlagPassworded = 0x10; // password protected
const uint32 k_unServerFlagPrivate = 0x20; // server shouldn't list on master server and const uint32 k_unServerFlagPrivate = 0x20; // server shouldn't list on master server and
// won't enforce authentication of users that connect to the server. // won't enforce authentication of users that connect to the server.
// Useful when you run a server where the clients may not // Useful when you run a server where the clients may not
// be connected to the internet but you want them to play (i.e LANs) // be connected to the internet but you want them to play (i.e LANs)
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
// client has been approved to connect to this game server // client has been approved to connect to this game server
struct GSClientApprove_t struct GSClientApprove_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 1 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 1 };
CSteamID m_SteamID; // SteamID of approved player CSteamID m_SteamID; // SteamID of approved player
CSteamID m_OwnerSteamID; // SteamID of original owner for game license CSteamID m_OwnerSteamID; // SteamID of original owner for game license
}; };
// client has been denied to connection to this game server // client has been denied to connection to this game server
struct GSClientDeny_t struct GSClientDeny_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 2 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 2 };
CSteamID m_SteamID; CSteamID m_SteamID;
EDenyReason m_eDenyReason; EDenyReason m_eDenyReason;
char m_rgchOptionalText[128]; char m_rgchOptionalText[128];
}; };
// request the game server should kick the user // request the game server should kick the user
struct GSClientKick_t struct GSClientKick_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 3 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 3 };
CSteamID m_SteamID; CSteamID m_SteamID;
EDenyReason m_eDenyReason; EDenyReason m_eDenyReason;
}; };
// NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks, // NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks,
// do not reuse them here. // do not reuse them here.
// client achievement info // client achievement info
struct GSClientAchievementStatus_t struct GSClientAchievementStatus_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 6 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 6 };
uint64 m_SteamID; uint64 m_SteamID;
char m_pchAchievement[128]; char m_pchAchievement[128];
bool m_bUnlocked; bool m_bUnlocked;
}; };
// received when the game server requests to be displayed as secure (VAC protected) // 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 // m_bSecure is true if the game server should display itself as secure to users, false otherwise
struct GSPolicyResponse_t struct GSPolicyResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 15 }; enum { k_iCallback = k_iSteamUserCallbacks + 15 };
uint8 m_bSecure; uint8 m_bSecure;
}; };
// GS gameplay stats info // GS gameplay stats info
struct GSGameplayStats_t struct GSGameplayStats_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 7 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 7 };
EResult m_eResult; // Result of the call EResult m_eResult; // Result of the call
int32 m_nRank; // Overall rank of the server (0-based) 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_unTotalConnects; // Total number of clients who have ever connected to the server
uint32 m_unTotalMinutesPlayed; // Total number of minutes ever played on the server uint32 m_unTotalMinutesPlayed; // Total number of minutes ever played on the server
}; };
// send as a reply to RequestUserGroupStatus() // send as a reply to RequestUserGroupStatus()
struct GSClientGroupStatus_t struct GSClientGroupStatus_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 8 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 8 };
CSteamID m_SteamIDUser; CSteamID m_SteamIDUser;
CSteamID m_SteamIDGroup; CSteamID m_SteamIDGroup;
bool m_bMember; bool m_bMember;
bool m_bOfficer; bool m_bOfficer;
}; };
// Sent as a reply to GetServerReputation() // Sent as a reply to GetServerReputation()
struct GSReputation_t struct GSReputation_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 9 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 9 };
EResult m_eResult; // Result of the call; EResult m_eResult; // Result of the call;
uint32 m_unReputationScore; // The reputation score for the game server uint32 m_unReputationScore; // The reputation score for the game server
bool m_bBanned; // True if the server is banned from the Steam bool m_bBanned; // True if the server is banned from the Steam
// master servers // master servers
// The following members are only filled out if m_bBanned is true. They will all // 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 // 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. // 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. // This information can be used to determine which server is bad.
uint32 m_unBannedIP; // The IP of the banned server uint32 m_unBannedIP; // The IP of the banned server
uint16 m_usBannedPort; // The port of the banned server uint16 m_usBannedPort; // The port of the banned server
uint64 m_ulBannedGameID; // The game ID the banned server is serving 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) uint32 m_unBanExpires; // Time the ban expires, expressed in the Unix epoch (seconds since 1/1/1970)
}; };
// Sent as a reply to AssociateWithClan() // Sent as a reply to AssociateWithClan()
struct AssociateWithClanResult_t struct AssociateWithClanResult_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 10 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 10 };
EResult m_eResult; // Result of the call; EResult m_eResult; // Result of the call;
}; };
// Sent as a reply to ComputeNewPlayerCompatibility() // Sent as a reply to ComputeNewPlayerCompatibility()
struct ComputeNewPlayerCompatibilityResult_t struct ComputeNewPlayerCompatibilityResult_t
{ {
enum { k_iCallback = k_iSteamGameServerCallbacks + 11 }; enum { k_iCallback = k_iSteamGameServerCallbacks + 11 };
EResult m_eResult; // Result of the call; EResult m_eResult; // Result of the call;
int m_cPlayersThatDontLikeCandidate; int m_cPlayersThatDontLikeCandidate;
int m_cPlayersThatCandidateDoesntLike; int m_cPlayersThatCandidateDoesntLike;
int m_cClanPlayersThatDontLikeCandidate; int m_cClanPlayersThatDontLikeCandidate;
CSteamID m_SteamIDCandidate; CSteamID m_SteamIDCandidate;
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMGAMESERVER_H #endif // ISTEAMGAMESERVER_H

230
sdk/steam/isteamgameserverstats.h
View file

@ -1,116 +1,116 @@
//====== Copyright © Valve Corporation, All rights reserved. ======= //====== Copyright © Valve Corporation, All rights reserved. =======
// //
// Purpose: interface for game servers to steam stats and achievements // Purpose: interface for game servers to steam stats and achievements
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMGAMESERVERSTATS_H #ifndef ISTEAMGAMESERVERSTATS_H
#define ISTEAMGAMESERVERSTATS_H #define ISTEAMGAMESERVERSTATS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for authenticating users via Steam to play on a game server // Purpose: Functions for authenticating users via Steam to play on a game server
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamGameServerStats class ISteamGameServerStats
{ {
public: public:
// downloads stats for the user // downloads stats for the user
// returns a GSStatsReceived_t callback when completed // returns a GSStatsReceived_t callback when completed
// if the user has no stats, GSStatsReceived_t.m_eResult will be set to k_EResultFail // 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 // 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 // users you'll need to call RequestUserStats() again to refresh any data
STEAM_CALL_RESULT( GSStatsReceived_t ) STEAM_CALL_RESULT( GSStatsReceived_t )
virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0; virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
// requests stat information for a user, usable after a successful call to RequestUserStats() // requests stat information for a user, usable after a successful call to RequestUserStats()
STEAM_FLAT_NAME( GetUserStatInt32 ) STEAM_FLAT_NAME( GetUserStatInt32 )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
STEAM_FLAT_NAME( GetUserStatFloat ) STEAM_FLAT_NAME( GetUserStatFloat )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0; virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
// Set / update stats and achievements. // Set / update stats and achievements.
// Note: These updates will work only on stats game servers are allowed to edit and only for // 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. // 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 // Set the IP range of your official servers on the Steamworks page
STEAM_FLAT_NAME( SetUserStatInt32 ) STEAM_FLAT_NAME( SetUserStatInt32 )
virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData ) = 0; virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData ) = 0;
STEAM_FLAT_NAME( SetUserStatFloat ) STEAM_FLAT_NAME( SetUserStatFloat )
virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, float fData ) = 0; 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 UpdateUserAvgRateStat( CSteamID steamIDUser, const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
virtual bool SetUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0; virtual bool SetUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0;
virtual bool ClearUserAchievement( 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. // 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 // If the callback has a result of k_EResultInvalidParam, one or more stats
// uploaded has been rejected, either because they broke constraints // uploaded has been rejected, either because they broke constraints
// or were out of date. In this case the server sends back updated values. // or were out of date. In this case the server sends back updated values.
// The stats should be re-iterated to keep in sync. // The stats should be re-iterated to keep in sync.
STEAM_CALL_RESULT( GSStatsStored_t ) STEAM_CALL_RESULT( GSStatsStored_t )
virtual SteamAPICall_t StoreUserStats( CSteamID steamIDUser ) = 0; virtual SteamAPICall_t StoreUserStats( CSteamID steamIDUser ) = 0;
}; };
#define STEAMGAMESERVERSTATS_INTERFACE_VERSION "SteamGameServerStats001" #define STEAMGAMESERVERSTATS_INTERFACE_VERSION "SteamGameServerStats001"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global accessor // Global accessor
inline ISteamGameServerStats *SteamGameServerStats(); inline ISteamGameServerStats *SteamGameServerStats();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServerStats *, SteamGameServerStats, STEAMGAMESERVERSTATS_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamGameServerStats *, SteamGameServerStats, STEAMGAMESERVERSTATS_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when the latests stats and achievements have been received // Purpose: called when the latests stats and achievements have been received
// from the server // from the server
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GSStatsReceived_t struct GSStatsReceived_t
{ {
enum { k_iCallback = k_iSteamGameServerStatsCallbacks }; enum { k_iCallback = k_iSteamGameServerStatsCallbacks };
EResult m_eResult; // Success / error fetching the stats EResult m_eResult; // Success / error fetching the stats
CSteamID m_steamIDUser; // The user for whom the stats are retrieved for 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 // Purpose: result of a request to store the user stats for a game
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GSStatsStored_t struct GSStatsStored_t
{ {
enum { k_iCallback = k_iSteamGameServerStatsCallbacks + 1 }; enum { k_iCallback = k_iSteamGameServerStatsCallbacks + 1 };
EResult m_eResult; // success / error EResult m_eResult; // success / error
CSteamID m_steamIDUser; // The user for whom the stats were stored CSteamID m_steamIDUser; // The user for whom the stats were stored
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Callback indicating that a user's stats have been unloaded. // Purpose: Callback indicating that a user's stats have been unloaded.
// Call RequestUserStats again to access stats for this user // Call RequestUserStats again to access stats for this user
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GSStatsUnloaded_t struct GSStatsUnloaded_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 };
CSteamID m_steamIDUser; // User whose stats have been unloaded CSteamID m_steamIDUser; // User whose stats have been unloaded
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMGAMESERVERSTATS_H #endif // ISTEAMGAMESERVERSTATS_H

150
sdk/steam/isteamgamestats.h
View file

@ -1,75 +1,75 @@
//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to steam for game play statistics // Purpose: interface to steam for game play statistics
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMGAMESTATS_H #ifndef ISTEAMGAMESTATS_H
#define ISTEAMGAMESTATS_H #define ISTEAMGAMESTATS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for recording game play sessions and details thereof // Purpose: Functions for recording game play sessions and details thereof
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamGameStats class ISteamGameStats
{ {
public: public:
virtual SteamAPICall_t GetNewSession( int8 nAccountType, uint64 ulAccountID, int32 nAppID, RTime32 rtTimeStarted ) = 0; virtual SteamAPICall_t GetNewSession( int8 nAccountType, uint64 ulAccountID, int32 nAppID, RTime32 rtTimeStarted ) = 0;
virtual SteamAPICall_t EndSession( uint64 ulSessionID, RTime32 rtTimeEnded, int nReasonCode ) = 0; virtual SteamAPICall_t EndSession( uint64 ulSessionID, RTime32 rtTimeEnded, int nReasonCode ) = 0;
virtual EResult AddSessionAttributeInt( uint64 ulSessionID, const char* pstrName, int32 nData ) = 0; virtual EResult AddSessionAttributeInt( uint64 ulSessionID, const char* pstrName, int32 nData ) = 0;
virtual EResult AddSessionAttributeString( uint64 ulSessionID, const char* pstrName, const char *pstrData ) = 0; virtual EResult AddSessionAttributeString( uint64 ulSessionID, const char* pstrName, const char *pstrData ) = 0;
virtual EResult AddSessionAttributeFloat( uint64 ulSessionID, const char* pstrName, float fData ) = 0; virtual EResult AddSessionAttributeFloat( uint64 ulSessionID, const char* pstrName, float fData ) = 0;
virtual EResult AddNewRow( uint64 *pulRowID, uint64 ulSessionID, const char *pstrTableName ) = 0; virtual EResult AddNewRow( uint64 *pulRowID, uint64 ulSessionID, const char *pstrTableName ) = 0;
virtual EResult CommitRow( uint64 ulRowID ) = 0; virtual EResult CommitRow( uint64 ulRowID ) = 0;
virtual EResult CommitOutstandingRows( uint64 ulSessionID ) = 0; virtual EResult CommitOutstandingRows( uint64 ulSessionID ) = 0;
virtual EResult AddRowAttributeInt( uint64 ulRowID, const char *pstrName, int32 nData ) = 0; virtual EResult AddRowAttributeInt( uint64 ulRowID, const char *pstrName, int32 nData ) = 0;
virtual EResult AddRowAtributeString( uint64 ulRowID, const char *pstrName, const char *pstrData ) = 0; virtual EResult AddRowAtributeString( uint64 ulRowID, const char *pstrName, const char *pstrData ) = 0;
virtual EResult AddRowAttributeFloat( uint64 ulRowID, const char *pstrName, float fData ) = 0; virtual EResult AddRowAttributeFloat( uint64 ulRowID, const char *pstrName, float fData ) = 0;
virtual EResult AddSessionAttributeInt64( uint64 ulSessionID, const char *pstrName, int64 llData ) = 0; virtual EResult AddSessionAttributeInt64( uint64 ulSessionID, const char *pstrName, int64 llData ) = 0;
virtual EResult AddRowAttributeInt64( uint64 ulRowID, const char *pstrName, int64 llData ) = 0; virtual EResult AddRowAttributeInt64( uint64 ulRowID, const char *pstrName, int64 llData ) = 0;
}; };
#define STEAMGAMESTATS_INTERFACE_VERSION "SteamGameStats001" #define STEAMGAMESTATS_INTERFACE_VERSION "SteamGameStats001"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: nAccountType for GetNewSession // Purpose: nAccountType for GetNewSession
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum EGameStatsAccountType enum EGameStatsAccountType
{ {
k_EGameStatsAccountType_Steam = 1, // ullAccountID is a 64-bit SteamID for a player k_EGameStatsAccountType_Steam = 1, // ullAccountID is a 64-bit SteamID for a player
k_EGameStatsAccountType_Xbox = 2, // ullAccountID is a 64-bit XUID k_EGameStatsAccountType_Xbox = 2, // ullAccountID is a 64-bit XUID
k_EGameStatsAccountType_SteamGameServer = 3, // ullAccountID is a 64-bit SteamID for a game server k_EGameStatsAccountType_SteamGameServer = 3, // ullAccountID is a 64-bit SteamID for a game server
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: callback for GetNewSession() method // Purpose: callback for GetNewSession() method
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GameStatsSessionIssued_t struct GameStatsSessionIssued_t
{ {
enum { k_iCallback = k_iSteamGameStatsCallbacks + 1 }; enum { k_iCallback = k_iSteamGameStatsCallbacks + 1 };
uint64 m_ulSessionID; uint64 m_ulSessionID;
EResult m_eResult; EResult m_eResult;
bool m_bCollectingAny; bool m_bCollectingAny;
bool m_bCollectingDetails; bool m_bCollectingDetails;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: callback for EndSession() method // Purpose: callback for EndSession() method
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GameStatsSessionClosed_t struct GameStatsSessionClosed_t
{ {
enum { k_iCallback = k_iSteamGameStatsCallbacks + 2 }; enum { k_iCallback = k_iSteamGameStatsCallbacks + 2 };
uint64 m_ulSessionID; uint64 m_ulSessionID;
EResult m_eResult; EResult m_eResult;
}; };
#endif // ISTEAMGAMESTATS_H #endif // ISTEAMGAMESTATS_H

966
sdk/steam/isteamhtmlsurface.h
View file

@ -1,483 +1,483 @@
//====== Copyright 1996-2013, Valve Corporation, All rights reserved. ======= //====== Copyright 1996-2013, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to display html pages in a texture // Purpose: interface to display html pages in a texture
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMHTMLSURFACE_H #ifndef ISTEAMHTMLSURFACE_H
#define ISTEAMHTMLSURFACE_H #define ISTEAMHTMLSURFACE_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
typedef uint32 HHTMLBrowser; typedef uint32 HHTMLBrowser;
const uint32 INVALID_HTMLBROWSER = 0; const uint32 INVALID_HTMLBROWSER = 0;
enum EHTMLMouseButton enum EHTMLMouseButton
{ {
eHTMLMouseButton_Left = 0, eHTMLMouseButton_Left = 0,
eHTMLMouseButton_Right = 1, eHTMLMouseButton_Right = 1,
eHTMLMouseButton_Middle = 2, eHTMLMouseButton_Middle = 2,
}; };
enum EHTMLMouseCursor enum EHTMLMouseCursor
{ {
k_EHTMLMouseCursor_User = 0, k_EHTMLMouseCursor_User = 0,
k_EHTMLMouseCursor_None, k_EHTMLMouseCursor_None,
k_EHTMLMouseCursor_Arrow, k_EHTMLMouseCursor_Arrow,
k_EHTMLMouseCursor_IBeam, k_EHTMLMouseCursor_IBeam,
k_EHTMLMouseCursor_Hourglass, k_EHTMLMouseCursor_Hourglass,
k_EHTMLMouseCursor_WaitArrow, k_EHTMLMouseCursor_WaitArrow,
k_EHTMLMouseCursor_Crosshair, k_EHTMLMouseCursor_Crosshair,
k_EHTMLMouseCursor_Up, k_EHTMLMouseCursor_Up,
k_EHTMLMouseCursor_SizeNW, k_EHTMLMouseCursor_SizeNW,
k_EHTMLMouseCursor_SizeSE, k_EHTMLMouseCursor_SizeSE,
k_EHTMLMouseCursor_SizeNE, k_EHTMLMouseCursor_SizeNE,
k_EHTMLMouseCursor_SizeSW, k_EHTMLMouseCursor_SizeSW,
k_EHTMLMouseCursor_SizeW, k_EHTMLMouseCursor_SizeW,
k_EHTMLMouseCursor_SizeE, k_EHTMLMouseCursor_SizeE,
k_EHTMLMouseCursor_SizeN, k_EHTMLMouseCursor_SizeN,
k_EHTMLMouseCursor_SizeS, k_EHTMLMouseCursor_SizeS,
k_EHTMLMouseCursor_SizeWE, k_EHTMLMouseCursor_SizeWE,
k_EHTMLMouseCursor_SizeNS, k_EHTMLMouseCursor_SizeNS,
k_EHTMLMouseCursor_SizeAll, k_EHTMLMouseCursor_SizeAll,
k_EHTMLMouseCursor_No, k_EHTMLMouseCursor_No,
k_EHTMLMouseCursor_Hand, k_EHTMLMouseCursor_Hand,
k_EHTMLMouseCursor_Blank, // don't show any custom cursor, just use your default k_EHTMLMouseCursor_Blank, // don't show any custom cursor, just use your default
k_EHTMLMouseCursor_MiddlePan, k_EHTMLMouseCursor_MiddlePan,
k_EHTMLMouseCursor_NorthPan, k_EHTMLMouseCursor_NorthPan,
k_EHTMLMouseCursor_NorthEastPan, k_EHTMLMouseCursor_NorthEastPan,
k_EHTMLMouseCursor_EastPan, k_EHTMLMouseCursor_EastPan,
k_EHTMLMouseCursor_SouthEastPan, k_EHTMLMouseCursor_SouthEastPan,
k_EHTMLMouseCursor_SouthPan, k_EHTMLMouseCursor_SouthPan,
k_EHTMLMouseCursor_SouthWestPan, k_EHTMLMouseCursor_SouthWestPan,
k_EHTMLMouseCursor_WestPan, k_EHTMLMouseCursor_WestPan,
k_EHTMLMouseCursor_NorthWestPan, k_EHTMLMouseCursor_NorthWestPan,
k_EHTMLMouseCursor_Alias, k_EHTMLMouseCursor_Alias,
k_EHTMLMouseCursor_Cell, k_EHTMLMouseCursor_Cell,
k_EHTMLMouseCursor_ColResize, k_EHTMLMouseCursor_ColResize,
k_EHTMLMouseCursor_CopyCur, k_EHTMLMouseCursor_CopyCur,
k_EHTMLMouseCursor_VerticalText, k_EHTMLMouseCursor_VerticalText,
k_EHTMLMouseCursor_RowResize, k_EHTMLMouseCursor_RowResize,
k_EHTMLMouseCursor_ZoomIn, k_EHTMLMouseCursor_ZoomIn,
k_EHTMLMouseCursor_ZoomOut, k_EHTMLMouseCursor_ZoomOut,
k_EHTMLMouseCursor_Help, k_EHTMLMouseCursor_Help,
k_EHTMLMouseCursor_Custom, k_EHTMLMouseCursor_Custom,
k_EHTMLMouseCursor_SizeNWSE, k_EHTMLMouseCursor_SizeNWSE,
k_EHTMLMouseCursor_SizeNESW, k_EHTMLMouseCursor_SizeNESW,
k_EHTMLMouseCursor_last, // custom cursors start from this value and up k_EHTMLMouseCursor_last, // custom cursors start from this value and up
}; };
enum EHTMLKeyModifiers enum EHTMLKeyModifiers
{ {
k_eHTMLKeyModifier_None = 0, k_eHTMLKeyModifier_None = 0,
k_eHTMLKeyModifier_AltDown = 1 << 0, k_eHTMLKeyModifier_AltDown = 1 << 0,
k_eHTMLKeyModifier_CtrlDown = 1 << 1, k_eHTMLKeyModifier_CtrlDown = 1 << 1,
k_eHTMLKeyModifier_ShiftDown = 1 << 2, k_eHTMLKeyModifier_ShiftDown = 1 << 2,
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for displaying HTML pages and interacting with them // Purpose: Functions for displaying HTML pages and interacting with them
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamHTMLSurface class ISteamHTMLSurface
{ {
public: public:
virtual ~ISteamHTMLSurface() {} virtual ~ISteamHTMLSurface() {}
// Must call init and shutdown when starting/ending use of the interface // Must call init and shutdown when starting/ending use of the interface
virtual bool Init() = 0; virtual bool Init() = 0;
virtual bool Shutdown() = 0; virtual bool Shutdown() = 0;
// Create a browser object for display of a html page, when creation is complete the call handle // 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. // 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 // 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. // identify your client on web servers.
// The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if // The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if
// you do not require this functionality. // you do not require this functionality.
// //
// YOU MUST HAVE IMPLEMENTED HANDLERS FOR HTML_BrowserReady_t, HTML_StartRequest_t, // 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 // 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 // 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 // not implement these callback handlers, the browser may appear to hang instead of
// navigating to new pages or triggering javascript popups. // navigating to new pages or triggering javascript popups.
// //
STEAM_CALL_RESULT( HTML_BrowserReady_t ) STEAM_CALL_RESULT( HTML_BrowserReady_t )
virtual SteamAPICall_t CreateBrowser( const char *pchUserAgent, const char *pchUserCSS ) = 0; 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 // 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; virtual void RemoveBrowser( HHTMLBrowser unBrowserHandle ) = 0;
// Navigate to this URL, results in a HTML_StartRequest_t as the request commences // 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; virtual void LoadURL( HHTMLBrowser unBrowserHandle, const char *pchURL, const char *pchPostData ) = 0;
// Tells the surface the size in pixels to display the surface // Tells the surface the size in pixels to display the surface
virtual void SetSize( HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight ) = 0; virtual void SetSize( HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight ) = 0;
// Stop the load of the current html page // Stop the load of the current html page
virtual void StopLoad( HHTMLBrowser unBrowserHandle ) = 0; virtual void StopLoad( HHTMLBrowser unBrowserHandle ) = 0;
// Reload (most likely from local cache) the current page // Reload (most likely from local cache) the current page
virtual void Reload( HHTMLBrowser unBrowserHandle ) = 0; virtual void Reload( HHTMLBrowser unBrowserHandle ) = 0;
// navigate back in the page history // navigate back in the page history
virtual void GoBack( HHTMLBrowser unBrowserHandle ) = 0; virtual void GoBack( HHTMLBrowser unBrowserHandle ) = 0;
// navigate forward in the page history // navigate forward in the page history
virtual void GoForward( HHTMLBrowser unBrowserHandle ) = 0; virtual void GoForward( HHTMLBrowser unBrowserHandle ) = 0;
// add this header to any url requests from this browser // add this header to any url requests from this browser
virtual void AddHeader( HHTMLBrowser unBrowserHandle, const char *pchKey, const char *pchValue ) = 0; virtual void AddHeader( HHTMLBrowser unBrowserHandle, const char *pchKey, const char *pchValue ) = 0;
// run this javascript script in the currently loaded page // run this javascript script in the currently loaded page
virtual void ExecuteJavascript( HHTMLBrowser unBrowserHandle, const char *pchScript ) = 0; virtual void ExecuteJavascript( HHTMLBrowser unBrowserHandle, const char *pchScript ) = 0;
// Mouse click and mouse movement commands // Mouse click and mouse movement commands
virtual void MouseUp( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; virtual void MouseUp( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
virtual void MouseDown( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; virtual void MouseDown( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
virtual void MouseDoubleClick( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0; virtual void MouseDoubleClick( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
// x and y are relative to the HTML bounds // x and y are relative to the HTML bounds
virtual void MouseMove( HHTMLBrowser unBrowserHandle, int x, int y ) = 0; virtual void MouseMove( HHTMLBrowser unBrowserHandle, int x, int y ) = 0;
// nDelta is pixels of scroll // nDelta is pixels of scroll
virtual void MouseWheel( HHTMLBrowser unBrowserHandle, int32 nDelta ) = 0; virtual void MouseWheel( HHTMLBrowser unBrowserHandle, int32 nDelta ) = 0;
// keyboard interactions, native keycode is the virtual key code value from your OS, system key flags the key to not // 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 // 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 KeyDown( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers, bool bIsSystemKey = false ) = 0;
virtual void KeyUp( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers ) = 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) // 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; virtual void KeyChar( HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0;
// programmatically scroll this many pixels on the page // programmatically scroll this many pixels on the page
virtual void SetHorizontalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0; virtual void SetHorizontalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0;
virtual void SetVerticalScroll( 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 // 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; virtual void SetKeyFocus( HHTMLBrowser unBrowserHandle, bool bHasKeyFocus ) = 0;
// open the current pages html code in the local editor of choice, used for debugging // open the current pages html code in the local editor of choice, used for debugging
virtual void ViewSource( HHTMLBrowser unBrowserHandle ) = 0; virtual void ViewSource( HHTMLBrowser unBrowserHandle ) = 0;
// copy the currently selected text on the html page to the local clipboard // copy the currently selected text on the html page to the local clipboard
virtual void CopyToClipboard( HHTMLBrowser unBrowserHandle ) = 0; virtual void CopyToClipboard( HHTMLBrowser unBrowserHandle ) = 0;
// paste from the local clipboard to the current html page // paste from the local clipboard to the current html page
virtual void PasteFromClipboard( HHTMLBrowser unBrowserHandle ) = 0; virtual void PasteFromClipboard( HHTMLBrowser unBrowserHandle ) = 0;
// find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element // 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; virtual void Find( HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse ) = 0;
// cancel a currently running find // cancel a currently running find
virtual void StopFind( HHTMLBrowser unBrowserHandle ) = 0; virtual void StopFind( HHTMLBrowser unBrowserHandle ) = 0;
// return details about the link at position x,y on the current page // return details about the link at position x,y on the current page
virtual void GetLinkAtPosition( HHTMLBrowser unBrowserHandle, int x, int y ) = 0; virtual void GetLinkAtPosition( HHTMLBrowser unBrowserHandle, int x, int y ) = 0;
// set a webcookie for the hostname in question // 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; 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) // 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; 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 // 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, // 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". // 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()". // 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; 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. // 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. // Specifies the ratio between physical and logical pixels.
virtual void SetDPIScalingFactor( HHTMLBrowser unBrowserHandle, float flDPIScaling ) = 0; virtual void SetDPIScalingFactor( HHTMLBrowser unBrowserHandle, float flDPIScaling ) = 0;
// Open HTML/JS developer tools // Open HTML/JS developer tools
virtual void OpenDeveloperTools( HHTMLBrowser unBrowserHandle ) = 0; virtual void OpenDeveloperTools( HHTMLBrowser unBrowserHandle ) = 0;
// CALLBACKS // CALLBACKS
// //
// These set of functions are used as responses to callback requests // These set of functions are used as responses to callback requests
// //
// You MUST call this in response to a HTML_StartRequest_t callback // 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 // 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 // on the current page. You can use this feature to limit the valid pages
// allowed in your HTML surface. // allowed in your HTML surface.
virtual void AllowStartRequest( HHTMLBrowser unBrowserHandle, bool bAllowed ) = 0; virtual void AllowStartRequest( HHTMLBrowser unBrowserHandle, bool bAllowed ) = 0;
// You MUST call this in response to a HTML_JSAlert_t or HTML_JSConfirm_t callback // 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 // Set bResult to true for the OK option of a confirm, use false otherwise
virtual void JSDialogResponse( HHTMLBrowser unBrowserHandle, bool bResult ) = 0; virtual void JSDialogResponse( HHTMLBrowser unBrowserHandle, bool bResult ) = 0;
// You MUST call this in response to a HTML_FileOpenDialog_t callback // You MUST call this in response to a HTML_FileOpenDialog_t callback
virtual void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles ) = 0; virtual void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles ) = 0;
}; };
#define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_005" #define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_005"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamHTMLSurface *SteamHTMLSurface(); inline ISteamHTMLSurface *SteamHTMLSurface();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTMLSurface *, SteamHTMLSurface, STEAMHTMLSURFACE_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTMLSurface *, SteamHTMLSurface, STEAMHTMLSURFACE_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: The browser is ready for use // Purpose: The browser is ready for use
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_BrowserReady_t, k_iSteamHTMLSurfaceCallbacks + 1 ) 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_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // this browser is now fully created and ready to navigate to pages
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: the browser has a pending paint // Purpose: the browser has a pending paint
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN(HTML_NeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 2) STEAM_CALLBACK_BEGIN(HTML_NeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 2)
STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the browser that needs the paint 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(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(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(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(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(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(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(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(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(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(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_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) STEAM_CALLBACK_END(12)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: The browser wanted to navigate to a new page // Purpose: The browser wanted to navigate to a new page
// NOTE - you MUST call AllowStartRequest in response to this callback // NOTE - you MUST call AllowStartRequest in response to this callback
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN(HTML_StartRequest_t, k_iSteamHTMLSurfaceCallbacks + 3) STEAM_CALLBACK_BEGIN(HTML_StartRequest_t, k_iSteamHTMLSurfaceCallbacks + 3)
STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface navigating 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(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(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(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_MEMBER(4, bool, bIsRedirect) // true if this was a http/html redirect from the last load request
STEAM_CALLBACK_END(5) STEAM_CALLBACK_END(5)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: The browser has been requested to close due to user interaction (usually from a javascript window.close() call) // 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_BEGIN(HTML_CloseBrowser_t, k_iSteamHTMLSurfaceCallbacks + 4)
STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface STEAM_CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: the browser is navigating to a new url // Purpose: the browser is navigating to a new url
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_URLChanged_t, k_iSteamHTMLSurfaceCallbacks + 5 ) STEAM_CALLBACK_BEGIN( HTML_URLChanged_t, k_iSteamHTMLSurfaceCallbacks + 5 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface navigating 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( 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( 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( 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( 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_MEMBER( 5, bool, bNewNavigation ) // true if this was from a fresh tab and not a click on an existing page
STEAM_CALLBACK_END(6) STEAM_CALLBACK_END(6)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: A page is finished loading // Purpose: A page is finished loading
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_FinishedRequest_t, k_iSteamHTMLSurfaceCallbacks + 6 ) STEAM_CALLBACK_BEGIN( HTML_FinishedRequest_t, k_iSteamHTMLSurfaceCallbacks + 6 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) //
STEAM_CALLBACK_MEMBER( 2, const char *, pchPageTitle ) // STEAM_CALLBACK_MEMBER( 2, const char *, pchPageTitle ) //
STEAM_CALLBACK_END(3) STEAM_CALLBACK_END(3)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: a request to load this url in a new tab // Purpose: a request to load this url in a new tab
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_OpenLinkInNewTab_t, k_iSteamHTMLSurfaceCallbacks + 7 ) STEAM_CALLBACK_BEGIN( HTML_OpenLinkInNewTab_t, k_iSteamHTMLSurfaceCallbacks + 7 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchURL ) //
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: the page has a new title now // Purpose: the page has a new title now
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_ChangedTitle_t, k_iSteamHTMLSurfaceCallbacks + 8 ) STEAM_CALLBACK_BEGIN( HTML_ChangedTitle_t, k_iSteamHTMLSurfaceCallbacks + 8 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) //
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: results from a search // Purpose: results from a search
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_SearchResults_t, k_iSteamHTMLSurfaceCallbacks + 9 ) STEAM_CALLBACK_BEGIN( HTML_SearchResults_t, k_iSteamHTMLSurfaceCallbacks + 9 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, uint32, unResults ) // STEAM_CALLBACK_MEMBER( 1, uint32, unResults ) //
STEAM_CALLBACK_MEMBER( 2, uint32, unCurrentMatch ) // STEAM_CALLBACK_MEMBER( 2, uint32, unCurrentMatch ) //
STEAM_CALLBACK_END(3) STEAM_CALLBACK_END(3)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: page history status changed on the ability to go backwards and forward // Purpose: page history status changed on the ability to go backwards and forward
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_CanGoBackAndForward_t, k_iSteamHTMLSurfaceCallbacks + 10 ) STEAM_CALLBACK_BEGIN( HTML_CanGoBackAndForward_t, k_iSteamHTMLSurfaceCallbacks + 10 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, bool, bCanGoBack ) // STEAM_CALLBACK_MEMBER( 1, bool, bCanGoBack ) //
STEAM_CALLBACK_MEMBER( 2, bool, bCanGoForward ) // STEAM_CALLBACK_MEMBER( 2, bool, bCanGoForward ) //
STEAM_CALLBACK_END(3) STEAM_CALLBACK_END(3)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: details on the visibility and size of the horizontal scrollbar // Purpose: details on the visibility and size of the horizontal scrollbar
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_HorizontalScroll_t, k_iSteamHTMLSurfaceCallbacks + 11 ) STEAM_CALLBACK_BEGIN( HTML_HorizontalScroll_t, k_iSteamHTMLSurfaceCallbacks + 11 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) // STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) //
STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) // STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) //
STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) // STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) //
STEAM_CALLBACK_MEMBER( 4, bool , bVisible ) // STEAM_CALLBACK_MEMBER( 4, bool , bVisible ) //
STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) // STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) //
STEAM_CALLBACK_END(6) STEAM_CALLBACK_END(6)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: details on the visibility and size of the vertical scrollbar // Purpose: details on the visibility and size of the vertical scrollbar
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_VerticalScroll_t, k_iSteamHTMLSurfaceCallbacks + 12 ) STEAM_CALLBACK_BEGIN( HTML_VerticalScroll_t, k_iSteamHTMLSurfaceCallbacks + 12 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) // STEAM_CALLBACK_MEMBER( 1, uint32, unScrollMax ) //
STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) // STEAM_CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) //
STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) // STEAM_CALLBACK_MEMBER( 3, float, flPageScale ) //
STEAM_CALLBACK_MEMBER( 4, bool, bVisible ) // STEAM_CALLBACK_MEMBER( 4, bool, bVisible ) //
STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) // STEAM_CALLBACK_MEMBER( 5, uint32, unPageSize ) //
STEAM_CALLBACK_END(6) STEAM_CALLBACK_END(6)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: response to GetLinkAtPosition call // Purpose: response to GetLinkAtPosition call
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_LinkAtPosition_t, k_iSteamHTMLSurfaceCallbacks + 13 ) STEAM_CALLBACK_BEGIN( HTML_LinkAtPosition_t, k_iSteamHTMLSurfaceCallbacks + 13 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, uint32, x ) // NOTE - Not currently set STEAM_CALLBACK_MEMBER( 1, uint32, x ) // NOTE - Not currently set
STEAM_CALLBACK_MEMBER( 2, uint32, y ) // NOTE - Not currently set STEAM_CALLBACK_MEMBER( 2, uint32, y ) // NOTE - Not currently set
STEAM_CALLBACK_MEMBER( 3, const char *, pchURL ) // STEAM_CALLBACK_MEMBER( 3, const char *, pchURL ) //
STEAM_CALLBACK_MEMBER( 4, bool, bInput ) // STEAM_CALLBACK_MEMBER( 4, bool, bInput ) //
STEAM_CALLBACK_MEMBER( 5, bool, bLiveLink ) // STEAM_CALLBACK_MEMBER( 5, bool, bLiveLink ) //
STEAM_CALLBACK_END(6) STEAM_CALLBACK_END(6)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: show a Javascript alert dialog, call JSDialogResponse // Purpose: show a Javascript alert dialog, call JSDialogResponse
// when the user dismisses this dialog (or right away to ignore it) // when the user dismisses this dialog (or right away to ignore it)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_JSAlert_t, k_iSteamHTMLSurfaceCallbacks + 14 ) STEAM_CALLBACK_BEGIN( HTML_JSAlert_t, k_iSteamHTMLSurfaceCallbacks + 14 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) //
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: show a Javascript confirmation dialog, call JSDialogResponse // Purpose: show a Javascript confirmation dialog, call JSDialogResponse
// when the user dismisses this dialog (or right away to ignore it) // when the user dismisses this dialog (or right away to ignore it)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_JSConfirm_t, k_iSteamHTMLSurfaceCallbacks + 15 ) STEAM_CALLBACK_BEGIN( HTML_JSConfirm_t, k_iSteamHTMLSurfaceCallbacks + 15 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchMessage ) //
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: when received show a file open dialog // Purpose: when received show a file open dialog
// then call FileLoadDialogResponse with the file(s) the user selected. // then call FileLoadDialogResponse with the file(s) the user selected.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_FileOpenDialog_t, k_iSteamHTMLSurfaceCallbacks + 16 ) STEAM_CALLBACK_BEGIN( HTML_FileOpenDialog_t, k_iSteamHTMLSurfaceCallbacks + 16 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) // STEAM_CALLBACK_MEMBER( 1, const char *, pchTitle ) //
STEAM_CALLBACK_MEMBER( 2, const char *, pchInitialFile ) // STEAM_CALLBACK_MEMBER( 2, const char *, pchInitialFile ) //
STEAM_CALLBACK_END(3) STEAM_CALLBACK_END(3)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: a new html window is being created. // Purpose: a new html window is being created.
// //
// IMPORTANT NOTE: at this time, the API does not allow you to acknowledge or // 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 // 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 // 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 // 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. // 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_BEGIN( HTML_NewWindow_t, k_iSteamHTMLSurfaceCallbacks + 21 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the current surface 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( 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( 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( 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( 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( 5, uint32, unTall ) // the total height of the pBGRA texture
STEAM_CALLBACK_MEMBER( 6, HHTMLBrowser, unNewWindow_BrowserHandle_IGNORE ) STEAM_CALLBACK_MEMBER( 6, HHTMLBrowser, unNewWindow_BrowserHandle_IGNORE )
STEAM_CALLBACK_END(7) STEAM_CALLBACK_END(7)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: change the cursor to display // Purpose: change the cursor to display
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_SetCursor_t, k_iSteamHTMLSurfaceCallbacks + 22 ) STEAM_CALLBACK_BEGIN( HTML_SetCursor_t, k_iSteamHTMLSurfaceCallbacks + 22 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EHTMLMouseCursor to display STEAM_CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EHTMLMouseCursor to display
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: informational message from the browser // Purpose: informational message from the browser
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_StatusText_t, k_iSteamHTMLSurfaceCallbacks + 23 ) STEAM_CALLBACK_BEGIN( HTML_StatusText_t, k_iSteamHTMLSurfaceCallbacks + 23 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the message text STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the message text
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: show a tooltip // Purpose: show a tooltip
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_ShowToolTip_t, k_iSteamHTMLSurfaceCallbacks + 24 ) STEAM_CALLBACK_BEGIN( HTML_ShowToolTip_t, k_iSteamHTMLSurfaceCallbacks + 24 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the tooltip text STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the tooltip text
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: update the text of an existing tooltip // Purpose: update the text of an existing tooltip
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_UpdateToolTip_t, k_iSteamHTMLSurfaceCallbacks + 25 ) STEAM_CALLBACK_BEGIN( HTML_UpdateToolTip_t, k_iSteamHTMLSurfaceCallbacks + 25 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the new tooltip text STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the new tooltip text
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: hide the tooltip you are showing // Purpose: hide the tooltip you are showing
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
STEAM_CALLBACK_BEGIN( HTML_HideToolTip_t, k_iSteamHTMLSurfaceCallbacks + 26 ) STEAM_CALLBACK_BEGIN( HTML_HideToolTip_t, k_iSteamHTMLSurfaceCallbacks + 26 )
STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: The browser has restarted due to an internal failure, use this new handle value // 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_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( 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_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) STEAM_CALLBACK_END(2)
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMHTMLSURFACE_H #endif // ISTEAMHTMLSURFACE_H

440
sdk/steam/isteamhttp.h
View file

@ -1,221 +1,221 @@
//====== Copyright © 1996-2009, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2009, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to http client // Purpose: interface to http client
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMHTTP_H #ifndef ISTEAMHTTP_H
#define ISTEAMHTTP_H #define ISTEAMHTTP_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
#include "steamhttpenums.h" #include "steamhttpenums.h"
// Handle to a HTTP Request handle // Handle to a HTTP Request handle
typedef uint32 HTTPRequestHandle; typedef uint32 HTTPRequestHandle;
#define INVALID_HTTPREQUEST_HANDLE 0 #define INVALID_HTTPREQUEST_HANDLE 0
typedef uint32 HTTPCookieContainerHandle; typedef uint32 HTTPCookieContainerHandle;
#define INVALID_HTTPCOOKIE_HANDLE 0 #define INVALID_HTTPCOOKIE_HANDLE 0
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: interface to http client // Purpose: interface to http client
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamHTTP class ISteamHTTP
{ {
public: public:
// Initializes a new HTTP request, returning a handle to use in further operations on it. Requires // 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, // 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/ // so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/
// or such. // or such.
virtual HTTPRequestHandle CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL ) = 0; 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 // 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. // 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; 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 // 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 // timeout is 60 seconds if you don't call this. Returns false if the handle is invalid, or the request
// has already been sent. // has already been sent.
virtual bool SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint32 unTimeoutSeconds ) = 0; 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 // 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. // 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; 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 // 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 // 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. // handle is invalid or the request is already sent.
virtual bool SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue ) = 0; 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 // Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on
// asynchronous response via callback. // asynchronous response via callback.
// //
// Note: If the user is in offline mode in Steam, then this will add a only-if-cached cache-control // 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. // header and only do a local cache lookup rather than sending any actual remote request.
virtual bool SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0; 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 // 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 // asynchronous response via callback for completion, and listen for HTTPRequestHeadersReceived_t and
// HTTPRequestDataReceived_t callbacks while streaming. // HTTPRequestDataReceived_t callbacks while streaming.
virtual bool SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0; 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 // 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. // 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; 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 // 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. // 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; virtual bool PrioritizeHTTPRequest( HTTPRequestHandle hRequest ) = 0;
// Checks if a response header is present in a HTTP response given a handle from HTTPRequestCompleted_t, also // 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 // returns the size of the header value if present so the caller and allocate a correctly sized buffer for
// GetHTTPResponseHeaderValue. // GetHTTPResponseHeaderValue.
virtual bool GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize ) = 0; 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 // 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 // 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. // 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; 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 // 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. // handle is invalid.
virtual bool GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *unBodySize ) = 0; 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 // 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 // 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. // the correct buffer size to use.
virtual bool GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0; 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 // 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 // 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. // do not match the size and offset sent in HTTPRequestDataReceived_t.
virtual bool GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0; 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 // Releases an HTTP response handle, should always be called to free resources after receiving a HTTPRequestCompleted_t
// callback and finishing using the response. // callback and finishing using the response.
virtual bool ReleaseHTTPRequest( HTTPRequestHandle hRequest ) = 0; 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 // 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 // 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. // zero for the duration of the request as the size is unknown until the connection closes.
virtual bool GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *pflPercentOut ) = 0; 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 // 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 // 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. // 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; 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 // 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 // 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 // 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 // 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. // repeat executions of your process.
virtual HTTPCookieContainerHandle CreateCookieContainer( bool bAllowResponsesToModify ) = 0; virtual HTTPCookieContainerHandle CreateCookieContainer( bool bAllowResponsesToModify ) = 0;
// Release a cookie container you are finished using, freeing it's memory // Release a cookie container you are finished using, freeing it's memory
virtual bool ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) = 0; virtual bool ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) = 0;
// Adds a cookie to the specified cookie container that will be used with future requests. // 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; 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 // Set the cookie container to use for a HTTP request
virtual bool SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ) = 0; 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 // 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; virtual bool SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const char *pchUserAgentInfo ) = 0;
// Disable or re-enable verification of SSL/TLS certificates. // Disable or re-enable verification of SSL/TLS certificates.
// By default, certificates are checked for all HTTPS requests. // By default, certificates are checked for all HTTPS requests.
virtual bool SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate ) = 0; 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 // 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 // which can bump everytime we get more data
virtual bool SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint32 unMilliseconds ) = 0; 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) // 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; virtual bool GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, bool *pbWasTimedOut ) = 0;
}; };
#define STEAMHTTP_INTERFACE_VERSION "STEAMHTTP_INTERFACE_VERSION003" #define STEAMHTTP_INTERFACE_VERSION "STEAMHTTP_INTERFACE_VERSION003"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamHTTP *SteamHTTP(); inline ISteamHTTP *SteamHTTP();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamHTTP, STEAMHTTP_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamHTTP, STEAMHTTP_INTERFACE_VERSION );
// Global accessor for the gameserver client // Global accessor for the gameserver client
inline ISteamHTTP *SteamGameServerHTTP(); inline ISteamHTTP *SteamGameServerHTTP();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamGameServerHTTP, STEAMHTTP_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamGameServerHTTP, STEAMHTTP_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
struct HTTPRequestCompleted_t struct HTTPRequestCompleted_t
{ {
enum { k_iCallback = k_iSteamHTTPCallbacks + 1 }; enum { k_iCallback = k_iSteamHTTPCallbacks + 1 };
// Handle value for the request that has completed. // Handle value for the request that has completed.
HTTPRequestHandle m_hRequest; HTTPRequestHandle m_hRequest;
// Context value that the user defined on the request that this callback is associated with, 0 if // Context value that the user defined on the request that this callback is associated with, 0 if
// no context value was set. // no context value was set.
uint64 m_ulContextValue; uint64 m_ulContextValue;
// This will be true if we actually got any sort of response from the server (even an error). // 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. // It will be false if we failed due to an internal error or client side network failure.
bool m_bRequestSuccessful; bool m_bRequestSuccessful;
// Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal // 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. // OK response, if you get something else you probably need to treat it as a failure.
EHTTPStatusCode m_eStatusCode; EHTTPStatusCode m_eStatusCode;
uint32 m_unBodySize; // Same as GetHTTPResponseBodySize() uint32 m_unBodySize; // Same as GetHTTPResponseBodySize()
}; };
struct HTTPRequestHeadersReceived_t struct HTTPRequestHeadersReceived_t
{ {
enum { k_iCallback = k_iSteamHTTPCallbacks + 2 }; enum { k_iCallback = k_iSteamHTTPCallbacks + 2 };
// Handle value for the request that has received headers. // Handle value for the request that has received headers.
HTTPRequestHandle m_hRequest; HTTPRequestHandle m_hRequest;
// Context value that the user defined on the request that this callback is associated with, 0 if // Context value that the user defined on the request that this callback is associated with, 0 if
// no context value was set. // no context value was set.
uint64 m_ulContextValue; uint64 m_ulContextValue;
}; };
struct HTTPRequestDataReceived_t struct HTTPRequestDataReceived_t
{ {
enum { k_iCallback = k_iSteamHTTPCallbacks + 3 }; enum { k_iCallback = k_iSteamHTTPCallbacks + 3 };
// Handle value for the request that has received data. // Handle value for the request that has received data.
HTTPRequestHandle m_hRequest; HTTPRequestHandle m_hRequest;
// Context value that the user defined on the request that this callback is associated with, 0 if // Context value that the user defined on the request that this callback is associated with, 0 if
// no context value was set. // no context value was set.
uint64 m_ulContextValue; uint64 m_ulContextValue;
// Offset to provide to GetHTTPStreamingResponseBodyData to get this chunk of data // Offset to provide to GetHTTPStreamingResponseBodyData to get this chunk of data
uint32 m_cOffset; uint32 m_cOffset;
// Size to provide to GetHTTPStreamingResponseBodyData to get this chunk of data // Size to provide to GetHTTPStreamingResponseBodyData to get this chunk of data
uint32 m_cBytesReceived; uint32 m_cBytesReceived;
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMHTTP_H #endif // ISTEAMHTTP_H

898
sdk/steam/isteaminventory.h
View file

@ -1,450 +1,450 @@
//====== Copyright © 1996-2014 Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2014 Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to Steam Inventory // Purpose: interface to Steam Inventory
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMINVENTORY_H #ifndef ISTEAMINVENTORY_H
#define ISTEAMINVENTORY_H #define ISTEAMINVENTORY_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
// Every individual instance of an item has a globally-unique ItemInstanceID. // Every individual instance of an item has a globally-unique ItemInstanceID.
// This ID is unique to the combination of (player, specific item instance) // 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. // and will not be transferred to another player or re-used for another item.
typedef uint64 SteamItemInstanceID_t; typedef uint64 SteamItemInstanceID_t;
static const SteamItemInstanceID_t k_SteamItemInstanceIDInvalid = (SteamItemInstanceID_t)~0; static const SteamItemInstanceID_t k_SteamItemInstanceIDInvalid = (SteamItemInstanceID_t)~0;
// Types of items in your game are identified by a 32-bit "item definition number". // 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 // 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 // zero are invalid, and numbers greater than or equal to one billion (1x10^9) are
// reserved for internal Steam use. // reserved for internal Steam use.
typedef int32 SteamItemDef_t; typedef int32 SteamItemDef_t;
enum ESteamItemFlags enum ESteamItemFlags
{ {
// Item status flags - these flags are permanently attached to specific item instances // 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. 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 // 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_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. 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. // 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. // Do not assume anything about the state of other flags which are not defined here.
}; };
struct SteamItemDetails_t struct SteamItemDetails_t
{ {
SteamItemInstanceID_t m_itemId; SteamItemInstanceID_t m_itemId;
SteamItemDef_t m_iDefinition; SteamItemDef_t m_iDefinition;
uint16 m_unQuantity; uint16 m_unQuantity;
uint16 m_unFlags; // see ESteamItemFlags uint16 m_unFlags; // see ESteamItemFlags
}; };
typedef int32 SteamInventoryResult_t; typedef int32 SteamInventoryResult_t;
static const SteamInventoryResult_t k_SteamInventoryResultInvalid = -1; static const SteamInventoryResult_t k_SteamInventoryResultInvalid = -1;
typedef uint64 SteamInventoryUpdateHandle_t; typedef uint64 SteamInventoryUpdateHandle_t;
const SteamInventoryUpdateHandle_t k_SteamInventoryUpdateHandleInvalid = 0xffffffffffffffffull; const SteamInventoryUpdateHandle_t k_SteamInventoryUpdateHandleInvalid = 0xffffffffffffffffull;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Steam Inventory query and manipulation API // Purpose: Steam Inventory query and manipulation API
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamInventory class ISteamInventory
{ {
public: public:
// INVENTORY ASYNC RESULT MANAGEMENT // INVENTORY ASYNC RESULT MANAGEMENT
// //
// Asynchronous inventory queries always output a result handle which can be used with // Asynchronous inventory queries always output a result handle which can be used with
// GetResultStatus, GetResultItems, etc. A SteamInventoryResultReady_t callback will // GetResultStatus, GetResultItems, etc. A SteamInventoryResultReady_t callback will
// be triggered when the asynchronous result becomes ready (or fails). // be triggered when the asynchronous result becomes ready (or fails).
// //
// Find out the status of an asynchronous inventory result handle. Possible values: // Find out the status of an asynchronous inventory result handle. Possible values:
// k_EResultPending - still in progress // k_EResultPending - still in progress
// k_EResultOK - done, result ready // k_EResultOK - done, result ready
// k_EResultExpired - done, result ready, maybe out of date (see DeserializeResult) // k_EResultExpired - done, result ready, maybe out of date (see DeserializeResult)
// k_EResultInvalidParam - ERROR: invalid API call parameters // k_EResultInvalidParam - ERROR: invalid API call parameters
// k_EResultServiceUnavailable - ERROR: service temporarily down, you may retry later // k_EResultServiceUnavailable - ERROR: service temporarily down, you may retry later
// k_EResultLimitExceeded - ERROR: operation would exceed per-user inventory limits // k_EResultLimitExceeded - ERROR: operation would exceed per-user inventory limits
// k_EResultFail - ERROR: unknown / generic error // k_EResultFail - ERROR: unknown / generic error
STEAM_METHOD_DESC(Find out the status of an asynchronous inventory result handle.) STEAM_METHOD_DESC(Find out the status of an asynchronous inventory result handle.)
virtual EResult GetResultStatus( SteamInventoryResult_t resultHandle ) = 0; virtual EResult GetResultStatus( SteamInventoryResult_t resultHandle ) = 0;
// Copies the contents of a result set into a flat array. The specific // 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. // contents of the result set depend on which query which was used.
STEAM_METHOD_DESC(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.) STEAM_METHOD_DESC(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, virtual bool GetResultItems( SteamInventoryResult_t resultHandle,
STEAM_OUT_ARRAY_COUNT( punOutItemsArraySize,Output array) SteamItemDetails_t *pOutItemsArray, STEAM_OUT_ARRAY_COUNT( punOutItemsArraySize,Output array) SteamItemDetails_t *pOutItemsArray,
uint32 *punOutItemsArraySize ) = 0; uint32 *punOutItemsArraySize ) = 0;
// In combination with GetResultItems, you can use GetResultItemProperty to retrieve // In combination with GetResultItems, you can use GetResultItemProperty to retrieve
// dynamic string properties for a given item returned in the result set. // dynamic string properties for a given item returned in the result set.
// //
// Property names are always composed of ASCII letters, numbers, and/or underscores. // 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 // Pass a NULL pointer for pchPropertyName to get a comma - separated list of available
// property names. // property names.
// //
// If pchValueBuffer is NULL, *punValueBufferSize will contain the // If pchValueBuffer is NULL, *punValueBufferSize will contain the
// suggested buffer size. Otherwise it will be the number of bytes actually copied // 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 // to pchValueBuffer. If the results do not fit in the given buffer, partial
// results may be copied. // results may be copied.
virtual bool GetResultItemProperty( SteamInventoryResult_t resultHandle, virtual bool GetResultItemProperty( SteamInventoryResult_t resultHandle,
uint32 unItemIndex, uint32 unItemIndex,
const char *pchPropertyName, const char *pchPropertyName,
STEAM_OUT_STRING_COUNT( punValueBufferSizeOut ) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) = 0; STEAM_OUT_STRING_COUNT( punValueBufferSizeOut ) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) = 0;
// Returns the server time at which the result was generated. Compare against // Returns the server time at which the result was generated. Compare against
// the value of IClientUtils::GetServerRealTime() to determine age. // the value of IClientUtils::GetServerRealTime() to determine age.
STEAM_METHOD_DESC(Returns the server time at which the result was generated. Compare against the value of IClientUtils::GetServerRealTime() to determine age.) STEAM_METHOD_DESC(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; virtual uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle ) = 0;
// Returns true if the result belongs to the target steam ID, false if the // 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 // 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. // that a remote player is not pretending to have a different user's inventory.
STEAM_METHOD_DESC(Returns true if the result belongs to the target steam ID or 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 users inventory.) STEAM_METHOD_DESC(Returns true if the result belongs to the target steam ID or 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 users inventory.)
virtual bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected ) = 0; virtual bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected ) = 0;
// Destroys a result handle and frees all associated memory. // Destroys a result handle and frees all associated memory.
STEAM_METHOD_DESC(Destroys a result handle and frees all associated memory.) STEAM_METHOD_DESC(Destroys a result handle and frees all associated memory.)
virtual void DestroyResult( SteamInventoryResult_t resultHandle ) = 0; virtual void DestroyResult( SteamInventoryResult_t resultHandle ) = 0;
// INVENTORY ASYNC QUERY // INVENTORY ASYNC QUERY
// //
// Captures the entire state of the current user's Steam inventory. // Captures the entire state of the current user's Steam inventory.
// You must call DestroyResult on this handle when you are done with it. // You must call DestroyResult on this handle when you are done with it.
// Returns false and sets *pResultHandle to zero if inventory is unavailable. // Returns false and sets *pResultHandle to zero if inventory is unavailable.
// Note: calls to this function are subject to rate limits and may return // 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 // 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, // this function only when you are about to display the user's full inventory,
// or if you expect that the inventory may have changed. // or if you expect that the inventory may have changed.
STEAM_METHOD_DESC(Captures the entire state of the current users Steam inventory.) STEAM_METHOD_DESC(Captures the entire state of the current users Steam inventory.)
virtual bool GetAllItems( SteamInventoryResult_t *pResultHandle ) = 0; virtual bool GetAllItems( SteamInventoryResult_t *pResultHandle ) = 0;
// Captures the state of a subset of the current user's Steam inventory, // 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 // 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 // can be serialized and passed to other players to "prove" that the current
// user owns specific items, without exposing the user's entire inventory. // user owns specific items, without exposing the user's entire inventory.
// For example, you could call GetItemsByID with the IDs of the user's // For example, you could call GetItemsByID with the IDs of the user's
// currently equipped cosmetic items and serialize this to a buffer, and // currently equipped cosmetic items and serialize this to a buffer, and
// then transmit this buffer to other players upon joining a game. // then transmit this buffer to other players upon joining a game.
STEAM_METHOD_DESC(Captures the state of a subset of the current users Steam inventory identified by an array of item instance IDs.) STEAM_METHOD_DESC(Captures the state of a subset of the current users Steam inventory identified by an array of item instance IDs.)
virtual bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unCountInstanceIDs ) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs ) = 0; virtual bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unCountInstanceIDs ) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs ) = 0;
// RESULT SERIALIZATION AND AUTHENTICATION // RESULT SERIALIZATION AND AUTHENTICATION
// //
// Serialized result sets contain a short signature which can't be forged // Serialized result sets contain a short signature which can't be forged
// or replayed across different game sessions. A result set can be serialized // or replayed across different game sessions. A result set can be serialized
// on the local client, transmitted to other players via your game networking, // 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 // and deserialized by the remote players. This is a secure way of preventing
// hackers from lying about posessing rare/high-value items. // hackers from lying about posessing rare/high-value items.
// Serializes a result set with signature bytes to an output buffer. Pass // Serializes a result set with signature bytes to an output buffer. Pass
// NULL as an output buffer to get the required size via punOutBufferSize. // 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 // The size of a serialized result depends on the number items which are being
// serialized. When securely transmitting items to other players, it is // serialized. When securely transmitting items to other players, it is
// recommended to use "GetItemsByID" first to create a minimal result set. // recommended to use "GetItemsByID" first to create a minimal result set.
// Results have a built-in timestamp which will be considered "expired" after // Results have a built-in timestamp which will be considered "expired" after
// an hour has elapsed. See DeserializeResult for expiration handling. // 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; 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 // Deserializes a result set and verifies the signature bytes. Returns false
// if bRequireFullOnlineVerify is set but Steam is running in Offline mode. // if bRequireFullOnlineVerify is set but Steam is running in Offline mode.
// Otherwise returns true and then delivers error codes via GetResultStatus. // Otherwise returns true and then delivers error codes via GetResultStatus.
// //
// The bRESERVED_MUST_BE_FALSE flag is reserved for future use and should not // The bRESERVED_MUST_BE_FALSE flag is reserved for future use and should not
// be set to true by your game at this time. // be set to true by your game at this time.
// //
// DeserializeResult has a potential soft-failure mode where the handle status // DeserializeResult has a potential soft-failure mode where the handle status
// is set to k_EResultExpired. GetResultItems() still succeeds in this mode. // 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 // 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 // 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 // in the result set may have been traded or consumed since the result set was
// generated. You could compare the timestamp from GetResultTimestamp() to // generated. You could compare the timestamp from GetResultTimestamp() to
// ISteamUtils::GetServerRealTime() to determine how old the data is. You could // ISteamUtils::GetServerRealTime() to determine how old the data is. You could
// simply ignore the "expired" result code and continue as normal, or you // 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. // 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; 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 // INVENTORY ASYNC MODIFICATION
// //
// GenerateItems() creates one or more items and then generates a SteamInventoryCallback_t // GenerateItems() creates one or more items and then generates a SteamInventoryCallback_t
// notification with a matching nCallbackContext parameter. This API is only intended // 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 prototyping - it is only usable by Steam accounts that belong to the publisher group
// for your game. // for your game.
// If punArrayQuantity is not NULL, it should be the same length as pArrayItems and should // If punArrayQuantity is not NULL, it should be the same length as pArrayItems and should
// describe the quantity of each item to generate. // 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; 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 // 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 // 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 // were granted, if any. If no items were granted because the user isn't eligible for any
// promotions, this is still considered a success. // promotions, this is still considered a success.
STEAM_METHOD_DESC(GrantPromoItems() checks the list of promotional items for which the user may be eligible and grants the items (one time only).) STEAM_METHOD_DESC(GrantPromoItems() checks the list of promotional items for which the user may be eligible and grants the items (one time only).)
virtual bool GrantPromoItems( SteamInventoryResult_t *pResultHandle ) = 0; virtual bool GrantPromoItems( SteamInventoryResult_t *pResultHandle ) = 0;
// AddPromoItem() / AddPromoItems() are restricted versions of GrantPromoItems(). Instead of // AddPromoItem() / AddPromoItems() are restricted versions of GrantPromoItems(). Instead of
// scanning for all eligible promotional items, the check is restricted to a single item // 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 // 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. // showing a specific promo item to the user.
virtual bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef ) = 0; 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; 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. // 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 // Not for the faint of heart - if your game implements item removal at all, a high-friction
// UI confirmation process is highly recommended. // UI confirmation process is highly recommended.
STEAM_METHOD_DESC(ConsumeItem() removes items from the inventory permanently.) STEAM_METHOD_DESC(ConsumeItem() removes items from the inventory permanently.)
virtual bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity ) = 0; virtual bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity ) = 0;
// ExchangeItems() is an atomic combination of item generation and consumption. // ExchangeItems() is an atomic combination of item generation and consumption.
// It can be used to implement crafting recipes or transmutations, or items which unpack // It can be used to implement crafting recipes or transmutations, or items which unpack
// themselves into other items (e.g., a chest). // themselves into other items (e.g., a chest).
// Exchange recipes are defined in the ItemDef, and explicitly list the required item // Exchange recipes are defined in the ItemDef, and explicitly list the required item
// types and resulting generated type. // types and resulting generated type.
// Exchange recipes are evaluated atomically by the Inventory Service; if the supplied // 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 // components do not match the recipe, or do not contain sufficient quantity, the
// exchange will fail. // exchange will fail.
virtual bool ExchangeItems( SteamInventoryResult_t *pResultHandle, 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(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; 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 // 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 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 // 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. // 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; virtual bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest ) = 0;
// TIMED DROPS AND PLAYTIME CREDIT // TIMED DROPS AND PLAYTIME CREDIT
// //
// Deprecated. Calling this method is not required for proper playtime accounting. // Deprecated. Calling this method is not required for proper playtime accounting.
STEAM_METHOD_DESC( Deprecated method. Playtime accounting is performed on the Steam servers. ) STEAM_METHOD_DESC( Deprecated method. Playtime accounting is performed on the Steam servers. )
virtual void SendItemDropHeartbeat() = 0; virtual void SendItemDropHeartbeat() = 0;
// Playtime credit must be consumed and turned into item drops by your game. Only item // 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 // 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. // 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 // 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 // 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 // hack their clients could modify the value of "dropListDefinition", so do not use it
// to directly control rarity. // to directly control rarity.
// See your Steamworks configuration to set playtime drop rates for individual itemdefs. // See your Steamworks configuration to set playtime drop rates for individual itemdefs.
// The client library will suppress too-frequent calls to this method. // The client library will suppress too-frequent calls to this method.
STEAM_METHOD_DESC(Playtime credit must be consumed and turned into item drops by your game.) STEAM_METHOD_DESC(Playtime credit must be consumed and turned into item drops by your game.)
virtual bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition ) = 0; virtual bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition ) = 0;
// Deprecated. This method is not supported. // Deprecated. This method is not supported.
virtual bool TradeItems( SteamInventoryResult_t *pResultHandle, CSteamID steamIDTradePartner, 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(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; STEAM_ARRAY_COUNT(nArrayGetLength) const SteamItemInstanceID_t *pArrayGet, STEAM_ARRAY_COUNT(nArrayGetLength) const uint32 *pArrayGetQuantity, uint32 nArrayGetLength ) = 0;
// ITEM DEFINITIONS // ITEM DEFINITIONS
// //
// Item definitions are a mapping of "definition IDs" (integers between 1 and 1000000) // 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 // 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. // 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 // 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 // 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. // 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. // LoadItemDefinitions triggers the automatic load and refresh of item definitions.
// Every time new item definitions are available (eg, from the dynamic addition of new // 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 // item types while players are still in-game), a SteamInventoryDefinitionUpdate_t
// callback will be fired. // callback will be fired.
STEAM_METHOD_DESC(LoadItemDefinitions triggers the automatic load and refresh of item definitions.) STEAM_METHOD_DESC(LoadItemDefinitions triggers the automatic load and refresh of item definitions.)
virtual bool LoadItemDefinitions() = 0; virtual bool LoadItemDefinitions() = 0;
// GetItemDefinitionIDs returns the set of all defined item definition IDs (which are // GetItemDefinitionIDs returns the set of all defined item definition IDs (which are
// defined via Steamworks configuration, and not necessarily contiguous integers). // defined via Steamworks configuration, and not necessarily contiguous integers).
// If pItemDefIDs is null, the call will return true and *punItemDefIDsArraySize will // 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 // 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. // return false if and only if there is not enough space in the output array.
virtual bool GetItemDefinitionIDs( virtual bool GetItemDefinitionIDs(
STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, 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; 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. // GetItemDefinitionProperty returns a string property from a given item definition.
// Note that some properties (for example, "name") may be localized and will depend // Note that some properties (for example, "name") may be localized and will depend
// on the current Steam language settings (see ISteamApps::GetCurrentGameLanguage). // on the current Steam language settings (see ISteamApps::GetCurrentGameLanguage).
// Property names are always composed of ASCII letters, numbers, and/or underscores. // 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 // Pass a NULL pointer for pchPropertyName to get a comma - separated list of available
// property names. If pchValueBuffer is NULL, *punValueBufferSize will contain the // property names. If pchValueBuffer is NULL, *punValueBufferSize will contain the
// suggested buffer size. Otherwise it will be the number of bytes actually copied // 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 // to pchValueBuffer. If the results do not fit in the given buffer, partial
// results may be copied. // results may be copied.
virtual bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName, virtual bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName,
STEAM_OUT_STRING_COUNT(punValueBufferSizeOut) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) = 0; 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 // 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. // 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. // An example usage of this is an item that becomes available every week.
STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t ) STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t )
virtual SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID ) = 0; virtual SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID ) = 0;
// After handling a SteamInventoryEligiblePromoItemDefIDs_t call result, use this // After handling a SteamInventoryEligiblePromoItemDefIDs_t call result, use this
// function to pull out the list of item definition ids that the user can be // function to pull out the list of item definition ids that the user can be
// manually granted via the AddPromoItems() call. // manually granted via the AddPromoItems() call.
virtual bool GetEligiblePromoItemDefinitionIDs( virtual bool GetEligiblePromoItemDefinitionIDs(
CSteamID steamID, CSteamID steamID,
STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, 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; 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 // Starts the purchase process for the given item definitions. The callback SteamInventoryStartPurchaseResult_t
// will be posted if Steam was able to initialize the transaction. // 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 // Once the purchase has been authorized and completed by the user, the callback SteamInventoryResultReady_t
// will be posted. // will be posted.
STEAM_CALL_RESULT( SteamInventoryStartPurchaseResult_t ) 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; 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 // Request current prices for all applicable item definitions
STEAM_CALL_RESULT( SteamInventoryRequestPricesResult_t ) STEAM_CALL_RESULT( SteamInventoryRequestPricesResult_t )
virtual SteamAPICall_t RequestPrices() = 0; virtual SteamAPICall_t RequestPrices() = 0;
// Returns the number of items with prices. Need to call RequestPrices() first. // Returns the number of items with prices. Need to call RequestPrices() first.
virtual uint32 GetNumItemsWithPrices() = 0; virtual uint32 GetNumItemsWithPrices() = 0;
// Returns item definition ids and their prices in the user's local currency. // Returns item definition ids and their prices in the user's local currency.
// Need to call RequestPrices() first. // Need to call RequestPrices() first.
virtual bool GetItemsWithPrices( STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pArrayItemDefs, Items with prices) SteamItemDef_t *pArrayItemDefs, 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 *pCurrentPrices,
STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pBasePrices, STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pBasePrices,
uint32 unArrayLength ) = 0; uint32 unArrayLength ) = 0;
// Retrieves the price for the item definition id // Retrieves the price for the item definition id
// Returns false if there is no price stored for the item definition. // Returns false if there is no price stored for the item definition.
virtual bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice ) = 0; virtual bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice ) = 0;
// Create a request to update properties on items // Create a request to update properties on items
virtual SteamInventoryUpdateHandle_t StartUpdateProperties() = 0; virtual SteamInventoryUpdateHandle_t StartUpdateProperties() = 0;
// Remove the property on the item // Remove the property on the item
virtual bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName ) = 0; virtual bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName ) = 0;
// Accessor methods to set properties on items // Accessor methods to set properties on items
STEAM_FLAT_NAME( SetPropertyString ) STEAM_FLAT_NAME( SetPropertyString )
virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue ) = 0; virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue ) = 0;
STEAM_FLAT_NAME( SetPropertyBool ) STEAM_FLAT_NAME( SetPropertyBool )
virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue ) = 0; virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue ) = 0;
STEAM_FLAT_NAME( SetPropertyInt64 ) STEAM_FLAT_NAME( SetPropertyInt64 )
virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue ) = 0; virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue ) = 0;
STEAM_FLAT_NAME( SetPropertyFloat ) STEAM_FLAT_NAME( SetPropertyFloat )
virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue ) = 0; virtual bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue ) = 0;
// Submit the update request by handle // Submit the update request by handle
virtual bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle ) = 0; virtual bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle ) = 0;
STEAM_METHOD_DESC(Look up the given token and return a pseudo-Inventory item.) STEAM_METHOD_DESC(Look up the given token and return a pseudo-Inventory item.)
virtual bool InspectItem( SteamInventoryResult_t *pResultHandle, const char *pchItemToken ) = 0; virtual bool InspectItem( SteamInventoryResult_t *pResultHandle, const char *pchItemToken ) = 0;
}; };
#define STEAMINVENTORY_INTERFACE_VERSION "STEAMINVENTORY_INTERFACE_V003" #define STEAMINVENTORY_INTERFACE_VERSION "STEAMINVENTORY_INTERFACE_V003"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamInventory *SteamInventory(); inline ISteamInventory *SteamInventory();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamInventory *, SteamInventory, STEAMINVENTORY_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamInventory *, SteamInventory, STEAMINVENTORY_INTERFACE_VERSION );
// Global accessor for the gameserver client // Global accessor for the gameserver client
inline ISteamInventory *SteamGameServerInventory(); inline ISteamInventory *SteamGameServerInventory();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamInventory *, SteamGameServerInventory, STEAMINVENTORY_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamInventory *, SteamGameServerInventory, STEAMINVENTORY_INTERFACE_VERSION );
#endif #endif
// SteamInventoryResultReady_t callbacks are fired whenever asynchronous // SteamInventoryResultReady_t callbacks are fired whenever asynchronous
// results transition from "Pending" to "OK" or an error state. There will // results transition from "Pending" to "OK" or an error state. There will
// always be exactly one callback per handle. // always be exactly one callback per handle.
struct SteamInventoryResultReady_t struct SteamInventoryResultReady_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 0 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 0 };
SteamInventoryResult_t m_handle; SteamInventoryResult_t m_handle;
EResult m_result; EResult m_result;
}; };
// SteamInventoryFullUpdate_t callbacks are triggered when GetAllItems // SteamInventoryFullUpdate_t callbacks are triggered when GetAllItems
// successfully returns a result which is newer / fresher than the last // successfully returns a result which is newer / fresher than the last
// known result. (It will not trigger if the inventory hasn't changed, // known result. (It will not trigger if the inventory hasn't changed,
// or if results from two overlapping calls are reversed in flight and // 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 earlier result is already known to be stale/out-of-date.)
// The normal ResultReady callback will still be triggered immediately // The normal ResultReady callback will still be triggered immediately
// afterwards; this is an additional notification for your convenience. // afterwards; this is an additional notification for your convenience.
struct SteamInventoryFullUpdate_t struct SteamInventoryFullUpdate_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 1 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 1 };
SteamInventoryResult_t m_handle; SteamInventoryResult_t m_handle;
}; };
// A SteamInventoryDefinitionUpdate_t callback is triggered whenever // A SteamInventoryDefinitionUpdate_t callback is triggered whenever
// item definitions have been updated, which could be in response to // item definitions have been updated, which could be in response to
// LoadItemDefinitions() or any other async request which required // LoadItemDefinitions() or any other async request which required
// a definition update in order to process results from the server. // a definition update in order to process results from the server.
struct SteamInventoryDefinitionUpdate_t struct SteamInventoryDefinitionUpdate_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 2 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 2 };
}; };
// Returned // Returned
struct SteamInventoryEligiblePromoItemDefIDs_t struct SteamInventoryEligiblePromoItemDefIDs_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 3 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 3 };
EResult m_result; EResult m_result;
CSteamID m_steamID; CSteamID m_steamID;
int m_numEligiblePromoItemDefs; int m_numEligiblePromoItemDefs;
bool m_bCachedData; // indicates that the data was retrieved from the cache and not the server bool m_bCachedData; // indicates that the data was retrieved from the cache and not the server
}; };
// Triggered from StartPurchase call // Triggered from StartPurchase call
struct SteamInventoryStartPurchaseResult_t struct SteamInventoryStartPurchaseResult_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 4 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 4 };
EResult m_result; EResult m_result;
uint64 m_ulOrderID; uint64 m_ulOrderID;
uint64 m_ulTransID; uint64 m_ulTransID;
}; };
// Triggered from RequestPrices // Triggered from RequestPrices
struct SteamInventoryRequestPricesResult_t struct SteamInventoryRequestPricesResult_t
{ {
enum { k_iCallback = k_iSteamInventoryCallbacks + 5 }; enum { k_iCallback = k_iSteamInventoryCallbacks + 5 };
EResult m_result; EResult m_result;
char m_rgchCurrency[4]; char m_rgchCurrency[4];
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMCONTROLLER_H #endif // ISTEAMCONTROLLER_H

206
sdk/steam/isteammasterserverupdater.h
View file

@ -1,103 +1,103 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to steam for retrieving list of game servers // Purpose: interface to steam for retrieving list of game servers
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMMASTERSERVERUPDATER_H #ifndef ISTEAMMASTERSERVERUPDATER_H
#define ISTEAMMASTERSERVERUPDATER_H #define ISTEAMMASTERSERVERUPDATER_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "isteamclient.h" #include "isteamclient.h"
#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE ((uint16)-1) #define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE ((uint16)-1)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Game engines use this to tell the Steam master servers // Purpose: Game engines use this to tell the Steam master servers
// about their games so their games can show up in the server browser. // about their games so their games can show up in the server browser.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamMasterServerUpdater class ISteamMasterServerUpdater
{ {
public: public:
// Call this as often as you like to tell the master server updater whether or not // Call this as often as you like to tell the master server updater whether or not
// you want it to be active (default: off). // you want it to be active (default: off).
virtual void SetActive( bool bActive ) = 0; virtual void SetActive( bool bActive ) = 0;
// You usually don't need to modify this. // You usually don't need to modify this.
// Pass -1 to use the default value for iHeartbeatInterval. // Pass -1 to use the default value for iHeartbeatInterval.
// Some mods change this. // Some mods change this.
virtual void SetHeartbeatInterval( int iHeartbeatInterval ) = 0; virtual void SetHeartbeatInterval( int iHeartbeatInterval ) = 0;
// These are in GameSocketShare mode, where instead of ISteamMasterServerUpdater creating its own // These are in GameSocketShare mode, where instead of ISteamMasterServerUpdater creating its own
// socket to talk to the master server on, it lets the game use its socket to forward messages // socket to talk to the master server on, it lets the game use its socket to forward messages
// back and forth. This prevents us from requiring server ops to open up yet another port // back and forth. This prevents us from requiring server ops to open up yet another port
// in their firewalls. // in their firewalls.
// //
// the IP address and port should be in host order, i.e 127.0.0.1 == 0x7f000001 // the IP address and port should be 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 // 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. // 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 // 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. // don't have to open up more ports on their firewalls.
// Call this when a packet that starts with 0xFFFFFFFF comes in. That means // Call this when a packet that starts with 0xFFFFFFFF comes in. That means
// it's for us. // it's for us.
virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0; 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. // 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. // 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. // 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. // Call this each frame until it returns 0.
virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0; virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;
// Functions to set various fields that are used to respond to queries. // Functions to set various fields that are used to respond to queries.
// Call this to set basic data that is passed to the server browser. // Call this to set basic data that is passed to the server browser.
virtual void SetBasicServerData( virtual void SetBasicServerData(
unsigned short nProtocolVersion, unsigned short nProtocolVersion,
bool bDedicatedServer, bool bDedicatedServer,
const char *pRegionName, const char *pRegionName,
const char *pProductName, const char *pProductName,
unsigned short nMaxReportedClients, unsigned short nMaxReportedClients,
bool bPasswordProtected, bool bPasswordProtected,
const char *pGameDescription ) = 0; const char *pGameDescription ) = 0;
// Call this to clear the whole list of key/values that are sent in rules queries. // Call this to clear the whole list of key/values that are sent in rules queries.
virtual void ClearAllKeyValues() = 0; virtual void ClearAllKeyValues() = 0;
// Call this to add/update a key/value pair. // Call this to add/update a key/value pair.
virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0; virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0;
// You can call this upon shutdown to clear out data stored for this game server and // You can call this upon shutdown to clear out data stored for this game server and
// to tell the master servers that this server is going away. // to tell the master servers that this server is going away.
virtual void NotifyShutdown() = 0; virtual void NotifyShutdown() = 0;
// Returns true if the master server has requested a restart. // Returns true if the master server has requested a restart.
// Only returns true once per request. // Only returns true once per request.
virtual bool WasRestartRequested() = 0; virtual bool WasRestartRequested() = 0;
// Force it to request a heartbeat from the master servers. // Force it to request a heartbeat from the master servers.
virtual void ForceHeartbeat() = 0; virtual void ForceHeartbeat() = 0;
// Manually edit and query the master server list. // Manually edit and query the master server list.
// It will provide name resolution and use the default master server port if none is provided. // It will provide name resolution and use the default master server port if none is provided.
virtual bool AddMasterServer( const char *pServerAddress ) = 0; virtual bool AddMasterServer( const char *pServerAddress ) = 0;
virtual bool RemoveMasterServer( const char *pServerAddress ) = 0; virtual bool RemoveMasterServer( const char *pServerAddress ) = 0;
virtual int GetNumMasterServers() = 0; virtual int GetNumMasterServers() = 0;
// Returns the # of bytes written to pOut. // Returns the # of bytes written to pOut.
virtual int GetMasterServerAddress( int iServer, char *pOut, int outBufferSize ) = 0; virtual int GetMasterServerAddress( int iServer, char *pOut, int outBufferSize ) = 0;
}; };
#define STEAMMASTERSERVERUPDATER_INTERFACE_VERSION "SteamMasterServerUpdater001" #define STEAMMASTERSERVERUPDATER_INTERFACE_VERSION "SteamMasterServerUpdater001"
#endif // ISTEAMMASTERSERVERUPDATER_H #endif // ISTEAMMASTERSERVERUPDATER_H

2174
sdk/steam/isteammatchmaking.h
View file

File diff suppressed because it is too large Load diff

146
sdk/steam/isteammusic.h
View file

@ -1,73 +1,73 @@
//============ Copyright (c) Valve Corporation, All rights reserved. ============ //============ Copyright (c) Valve Corporation, All rights reserved. ============
#ifndef ISTEAMMUSIC_H #ifndef ISTEAMMUSIC_H
#define ISTEAMMUSIC_H #define ISTEAMMUSIC_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: // Purpose:
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum AudioPlayback_Status enum AudioPlayback_Status
{ {
AudioPlayback_Undefined = 0, AudioPlayback_Undefined = 0,
AudioPlayback_Playing = 1, AudioPlayback_Playing = 1,
AudioPlayback_Paused = 2, AudioPlayback_Paused = 2,
AudioPlayback_Idle = 3 AudioPlayback_Idle = 3
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions to control music playback in the steam client // Purpose: Functions to control music playback in the steam client
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamMusic class ISteamMusic
{ {
public: public:
virtual bool BIsEnabled() = 0; virtual bool BIsEnabled() = 0;
virtual bool BIsPlaying() = 0; virtual bool BIsPlaying() = 0;
virtual AudioPlayback_Status GetPlaybackStatus() = 0; virtual AudioPlayback_Status GetPlaybackStatus() = 0;
virtual void Play() = 0; virtual void Play() = 0;
virtual void Pause() = 0; virtual void Pause() = 0;
virtual void PlayPrevious() = 0; virtual void PlayPrevious() = 0;
virtual void PlayNext() = 0; virtual void PlayNext() = 0;
// volume is between 0.0 and 1.0 // volume is between 0.0 and 1.0
virtual void SetVolume( float flVolume ) = 0; virtual void SetVolume( float flVolume ) = 0;
virtual float GetVolume() = 0; virtual float GetVolume() = 0;
}; };
#define STEAMMUSIC_INTERFACE_VERSION "STEAMMUSIC_INTERFACE_VERSION001" #define STEAMMUSIC_INTERFACE_VERSION "STEAMMUSIC_INTERFACE_VERSION001"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamMusic *SteamMusic(); inline ISteamMusic *SteamMusic();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusic *, SteamMusic, STEAMMUSIC_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusic *, SteamMusic, STEAMMUSIC_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
STEAM_CALLBACK_BEGIN( PlaybackStatusHasChanged_t, k_iSteamMusicCallbacks + 1 ) STEAM_CALLBACK_BEGIN( PlaybackStatusHasChanged_t, k_iSteamMusicCallbacks + 1 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( VolumeHasChanged_t, k_iSteamMusicCallbacks + 2 ) STEAM_CALLBACK_BEGIN( VolumeHasChanged_t, k_iSteamMusicCallbacks + 2 )
STEAM_CALLBACK_MEMBER( 0, float, m_flNewVolume ) STEAM_CALLBACK_MEMBER( 0, float, m_flNewVolume )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
#pragma pack( pop ) #pragma pack( pop )
#endif // #define ISTEAMMUSIC_H #endif // #define ISTEAMMUSIC_H

270
sdk/steam/isteammusicremote.h
View file

@ -1,135 +1,135 @@
//============ Copyright (c) Valve Corporation, All rights reserved. ============ //============ Copyright (c) Valve Corporation, All rights reserved. ============
#ifndef ISTEAMMUSICREMOTE_H #ifndef ISTEAMMUSICREMOTE_H
#define ISTEAMMUSICREMOTE_H #define ISTEAMMUSICREMOTE_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
#include "isteammusic.h" #include "isteammusic.h"
#define k_SteamMusicNameMaxLength 255 #define k_SteamMusicNameMaxLength 255
#define k_SteamMusicPNGMaxLength 65535 #define k_SteamMusicPNGMaxLength 65535
class ISteamMusicRemote class ISteamMusicRemote
{ {
public: public:
// Service Definition // Service Definition
virtual bool RegisterSteamMusicRemote( const char *pchName ) = 0; virtual bool RegisterSteamMusicRemote( const char *pchName ) = 0;
virtual bool DeregisterSteamMusicRemote() = 0; virtual bool DeregisterSteamMusicRemote() = 0;
virtual bool BIsCurrentMusicRemote() = 0; virtual bool BIsCurrentMusicRemote() = 0;
virtual bool BActivationSuccess( bool bValue ) = 0; virtual bool BActivationSuccess( bool bValue ) = 0;
virtual bool SetDisplayName( const char *pchDisplayName ) = 0; virtual bool SetDisplayName( const char *pchDisplayName ) = 0;
virtual bool SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength ) = 0; virtual bool SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength ) = 0;
// Abilities for the user interface // Abilities for the user interface
virtual bool EnablePlayPrevious(bool bValue) = 0; virtual bool EnablePlayPrevious(bool bValue) = 0;
virtual bool EnablePlayNext( bool bValue ) = 0; virtual bool EnablePlayNext( bool bValue ) = 0;
virtual bool EnableShuffled( bool bValue ) = 0; virtual bool EnableShuffled( bool bValue ) = 0;
virtual bool EnableLooped( bool bValue ) = 0; virtual bool EnableLooped( bool bValue ) = 0;
virtual bool EnableQueue( bool bValue ) = 0; virtual bool EnableQueue( bool bValue ) = 0;
virtual bool EnablePlaylists( bool bValue ) = 0; virtual bool EnablePlaylists( bool bValue ) = 0;
// Status // Status
virtual bool UpdatePlaybackStatus( AudioPlayback_Status nStatus ) = 0; virtual bool UpdatePlaybackStatus( AudioPlayback_Status nStatus ) = 0;
virtual bool UpdateShuffled( bool bValue ) = 0; virtual bool UpdateShuffled( bool bValue ) = 0;
virtual bool UpdateLooped( bool bValue ) = 0; virtual bool UpdateLooped( bool bValue ) = 0;
virtual bool UpdateVolume( float flValue ) = 0; // volume is between 0.0 and 1.0 virtual bool UpdateVolume( float flValue ) = 0; // volume is between 0.0 and 1.0
// Current Entry // Current Entry
virtual bool CurrentEntryWillChange() = 0; virtual bool CurrentEntryWillChange() = 0;
virtual bool CurrentEntryIsAvailable( bool bAvailable ) = 0; virtual bool CurrentEntryIsAvailable( bool bAvailable ) = 0;
virtual bool UpdateCurrentEntryText( const char *pchText ) = 0; virtual bool UpdateCurrentEntryText( const char *pchText ) = 0;
virtual bool UpdateCurrentEntryElapsedSeconds( int nValue ) = 0; virtual bool UpdateCurrentEntryElapsedSeconds( int nValue ) = 0;
virtual bool UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength ) = 0; virtual bool UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength ) = 0;
virtual bool CurrentEntryDidChange() = 0; virtual bool CurrentEntryDidChange() = 0;
// Queue // Queue
virtual bool QueueWillChange() = 0; virtual bool QueueWillChange() = 0;
virtual bool ResetQueueEntries() = 0; virtual bool ResetQueueEntries() = 0;
virtual bool SetQueueEntry( int nID, int nPosition, const char *pchEntryText ) = 0; virtual bool SetQueueEntry( int nID, int nPosition, const char *pchEntryText ) = 0;
virtual bool SetCurrentQueueEntry( int nID ) = 0; virtual bool SetCurrentQueueEntry( int nID ) = 0;
virtual bool QueueDidChange() = 0; virtual bool QueueDidChange() = 0;
// Playlist // Playlist
virtual bool PlaylistWillChange() = 0; virtual bool PlaylistWillChange() = 0;
virtual bool ResetPlaylistEntries() = 0; virtual bool ResetPlaylistEntries() = 0;
virtual bool SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText ) = 0; virtual bool SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText ) = 0;
virtual bool SetCurrentPlaylistEntry( int nID ) = 0; virtual bool SetCurrentPlaylistEntry( int nID ) = 0;
virtual bool PlaylistDidChange() = 0; virtual bool PlaylistDidChange() = 0;
}; };
#define STEAMMUSICREMOTE_INTERFACE_VERSION "STEAMMUSICREMOTE_INTERFACE_VERSION001" #define STEAMMUSICREMOTE_INTERFACE_VERSION "STEAMMUSICREMOTE_INTERFACE_VERSION001"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamMusicRemote *SteamMusicRemote(); inline ISteamMusicRemote *SteamMusicRemote();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusicRemote *, SteamMusicRemote, STEAMMUSICREMOTE_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamMusicRemote *, SteamMusicRemote, STEAMMUSICREMOTE_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillActivate_t, k_iSteamMusicRemoteCallbacks + 1) STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillActivate_t, k_iSteamMusicRemoteCallbacks + 1)
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillDeactivate_t, k_iSteamMusicRemoteCallbacks + 2 ) STEAM_CALLBACK_BEGIN( MusicPlayerRemoteWillDeactivate_t, k_iSteamMusicRemoteCallbacks + 2 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerRemoteToFront_t, k_iSteamMusicRemoteCallbacks + 3 ) STEAM_CALLBACK_BEGIN( MusicPlayerRemoteToFront_t, k_iSteamMusicRemoteCallbacks + 3 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWillQuit_t, k_iSteamMusicRemoteCallbacks + 4 ) STEAM_CALLBACK_BEGIN( MusicPlayerWillQuit_t, k_iSteamMusicRemoteCallbacks + 4 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlay_t, k_iSteamMusicRemoteCallbacks + 5 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlay_t, k_iSteamMusicRemoteCallbacks + 5 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsPause_t, k_iSteamMusicRemoteCallbacks + 6 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsPause_t, k_iSteamMusicRemoteCallbacks + 6 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayPrevious_t, k_iSteamMusicRemoteCallbacks + 7 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayPrevious_t, k_iSteamMusicRemoteCallbacks + 7 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayNext_t, k_iSteamMusicRemoteCallbacks + 8 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayNext_t, k_iSteamMusicRemoteCallbacks + 8 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsShuffled_t, k_iSteamMusicRemoteCallbacks + 9 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsShuffled_t, k_iSteamMusicRemoteCallbacks + 9 )
STEAM_CALLBACK_MEMBER( 0, bool, m_bShuffled ) STEAM_CALLBACK_MEMBER( 0, bool, m_bShuffled )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsLooped_t, k_iSteamMusicRemoteCallbacks + 10 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsLooped_t, k_iSteamMusicRemoteCallbacks + 10 )
STEAM_CALLBACK_MEMBER(0, bool, m_bLooped ) STEAM_CALLBACK_MEMBER(0, bool, m_bLooped )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsVolume_t, k_iSteamMusicCallbacks + 11 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsVolume_t, k_iSteamMusicCallbacks + 11 )
STEAM_CALLBACK_MEMBER(0, float, m_flNewVolume) STEAM_CALLBACK_MEMBER(0, float, m_flNewVolume)
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( MusicPlayerSelectsQueueEntry_t, k_iSteamMusicCallbacks + 12 ) STEAM_CALLBACK_BEGIN( MusicPlayerSelectsQueueEntry_t, k_iSteamMusicCallbacks + 12 )
STEAM_CALLBACK_MEMBER(0, int, nID ) STEAM_CALLBACK_MEMBER(0, int, nID )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( MusicPlayerSelectsPlaylistEntry_t, k_iSteamMusicCallbacks + 13 ) STEAM_CALLBACK_BEGIN( MusicPlayerSelectsPlaylistEntry_t, k_iSteamMusicCallbacks + 13 )
STEAM_CALLBACK_MEMBER(0, int, nID ) STEAM_CALLBACK_MEMBER(0, int, nID )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayingRepeatStatus_t, k_iSteamMusicRemoteCallbacks + 14 ) STEAM_CALLBACK_BEGIN( MusicPlayerWantsPlayingRepeatStatus_t, k_iSteamMusicRemoteCallbacks + 14 )
STEAM_CALLBACK_MEMBER(0, int, m_nPlayingRepeatStatus ) STEAM_CALLBACK_MEMBER(0, int, m_nPlayingRepeatStatus )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
#pragma pack( pop ) #pragma pack( pop )
#endif // #define ISTEAMMUSICREMOTE_H #endif // #define ISTEAMMUSICREMOTE_H

682
sdk/steam/isteamnetworking.h
View file

@ -1,341 +1,341 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to steam managing network connections between game clients & servers // Purpose: interface to steam managing network connections between game clients & servers
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMNETWORKING #ifndef ISTEAMNETWORKING
#define ISTEAMNETWORKING #define ISTEAMNETWORKING
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// list of possible errors returned by SendP2PPacket() API // list of possible errors returned by SendP2PPacket() API
// these will be posted in the P2PSessionConnectFail_t callback // these will be posted in the P2PSessionConnectFail_t callback
enum EP2PSessionError enum EP2PSessionError
{ {
k_EP2PSessionErrorNone = 0, k_EP2PSessionErrorNone = 0,
k_EP2PSessionErrorNotRunningApp = 1, // target is not running the same game k_EP2PSessionErrorNotRunningApp = 1, // target is not running the same game
k_EP2PSessionErrorNoRightsToApp = 2, // local user doesn't own the app that is running k_EP2PSessionErrorNoRightsToApp = 2, // local user doesn't own the app that is running
k_EP2PSessionErrorDestinationNotLoggedIn = 3, // target user isn't connected to Steam k_EP2PSessionErrorDestinationNotLoggedIn = 3, // target user isn't connected to Steam
k_EP2PSessionErrorTimeout = 4, // target isn't responding, perhaps not calling AcceptP2PSessionWithUser() k_EP2PSessionErrorTimeout = 4, // target isn't responding, perhaps not calling AcceptP2PSessionWithUser()
// corporate firewalls can also block this (NAT traversal is not firewall traversal) // 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 // make sure that UDP ports 3478, 4379, and 4380 are open in an outbound direction
k_EP2PSessionErrorMax = 5 k_EP2PSessionErrorMax = 5
}; };
// SendP2PPacket() send types // SendP2PPacket() send types
// Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets // Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets
enum EP2PSend 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). // 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 // 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. // there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again.
k_EP2PSendUnreliable = 0, 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 // 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. // 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 // This is only really useful for kinds of data that should never buffer up, i.e. voice payload packets
k_EP2PSendUnreliableNoDelay = 1, k_EP2PSendUnreliableNoDelay = 1,
// Reliable message send. Can send up to 1MB of data in a single message. // 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. // 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, k_EP2PSendReliable = 2,
// As above, but applies the Nagle algorithm to the send - sends will accumulate // 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). // 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 // 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 // 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. // do a normal k_EP2PSendReliable to force all the buffered data to be sent.
k_EP2PSendReliableWithBuffering = 3, k_EP2PSendReliableWithBuffering = 3,
}; };
// connection state to a specified user, returned by GetP2PSessionState() // 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 // 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 ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
struct P2PSessionState_t struct P2PSessionState_t
{ {
uint8 m_bConnectionActive; // true if we've got an active open connection 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_bConnecting; // true if we're currently trying to establish a connection
uint8 m_eP2PSessionError; // last error recorded (see enum above) uint8 m_eP2PSessionError; // last error recorded (see enum above)
uint8 m_bUsingRelay; // true if it's going through a relay server (TURN) uint8 m_bUsingRelay; // true if it's going through a relay server (TURN)
int32 m_nBytesQueuedForSend; int32 m_nBytesQueuedForSend;
int32 m_nPacketsQueuedForSend; int32 m_nPacketsQueuedForSend;
uint32 m_nRemoteIP; // potential IP:Port of remote host. Could be TURN server. 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 uint16 m_nRemotePort; // Only exists for compatibility with older authentication api's
}; };
#pragma pack( pop ) #pragma pack( pop )
// handle to a socket // handle to a socket
typedef uint32 SNetSocket_t; // CreateP2PConnectionSocket() typedef uint32 SNetSocket_t; // CreateP2PConnectionSocket()
typedef uint32 SNetListenSocket_t; // CreateListenSocket() typedef uint32 SNetListenSocket_t; // CreateListenSocket()
// connection progress indicators, used by CreateP2PConnectionSocket() // connection progress indicators, used by CreateP2PConnectionSocket()
enum ESNetSocketState enum ESNetSocketState
{ {
k_ESNetSocketStateInvalid = 0, k_ESNetSocketStateInvalid = 0,
// communication is valid // communication is valid
k_ESNetSocketStateConnected = 1, k_ESNetSocketStateConnected = 1,
// states while establishing a connection // states while establishing a connection
k_ESNetSocketStateInitiated = 10, // the connection state machine has started k_ESNetSocketStateInitiated = 10, // the connection state machine has started
// p2p connections // p2p connections
k_ESNetSocketStateLocalCandidatesFound = 11, // we've found our local IP info 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 k_ESNetSocketStateReceivedRemoteCandidates = 12,// we've received information from the remote machine, via the Steam back-end, about their IP info
// direct connections // direct connections
k_ESNetSocketStateChallengeHandshake = 15, // we've received a challenge packet from the server k_ESNetSocketStateChallengeHandshake = 15, // we've received a challenge packet from the server
// failure states // failure states
k_ESNetSocketStateDisconnecting = 21, // the API shut it down, and we're in the process of telling the other end 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_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_ESNetSocketStateTimeoutDuringConnect = 23, // we timed out while trying to creating the connection
k_ESNetSocketStateRemoteEndDisconnected = 24, // the remote end has disconnected from us 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 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 // describes how the socket is currently connected
enum ESNetSocketConnectionType enum ESNetSocketConnectionType
{ {
k_ESNetSocketConnectionTypeNotConnected = 0, k_ESNetSocketConnectionTypeNotConnected = 0,
k_ESNetSocketConnectionTypeUDP = 1, k_ESNetSocketConnectionTypeUDP = 1,
k_ESNetSocketConnectionTypeUDPRelay = 2, k_ESNetSocketConnectionTypeUDPRelay = 2,
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for making connections and sending data between clients, // Purpose: Functions for making connections and sending data between clients,
// traversing NAT's where possible // traversing NAT's where possible
// //
// NOTE: This interface is deprecated and may be removed in a future release of // NOTE: This interface is deprecated and may be removed in a future release of
/// the Steamworks SDK. Please see ISteamNetworkingSockets and /// the Steamworks SDK. Please see ISteamNetworkingSockets and
/// ISteamNetworkingMessages /// ISteamNetworkingMessages
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamNetworking class ISteamNetworking
{ {
public: public:
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
// //
// UDP-style (connectionless) networking interface. These functions send messages using // UDP-style (connectionless) networking interface. These functions send messages using
// an API organized around the destination. Reliable and unreliable messages are supported. // 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. // 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. // Both interface styles can send both reliable and unreliable messages.
// //
// Automatically establishes NAT-traversing or Relay server connections // Automatically establishes NAT-traversing or Relay server connections
// //
// These APIs are deprecated, and may be removed in a future version of the Steamworks // These APIs are deprecated, and may be removed in a future version of the Steamworks
// SDK. See ISteamNetworkingMessages. // SDK. See ISteamNetworkingMessages.
// Sends a P2P packet to the specified user // Sends a P2P packet to the specified user
// UDP-like, unreliable and a max packet size of 1200 bytes // UDP-like, unreliable and a max packet size of 1200 bytes
// the first packet send may be delayed as the NAT-traversal code runs // 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 // 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 // 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() // 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 // 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 // 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; 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 // 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; virtual bool IsP2PPacketAvailable( uint32 *pcubMsgSize, int nChannel = 0 ) = 0;
// reads in a packet that has been sent from another user via SendP2PPacket() // 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 // 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 // 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 // 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; 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 // 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 // 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 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 // 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 // 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) // (if you've called SendP2PPacket() on the other user, this implicitly accepts the session request)
virtual bool AcceptP2PSessionWithUser( CSteamID steamIDRemote ) = 0; virtual bool AcceptP2PSessionWithUser( CSteamID steamIDRemote ) = 0;
// call CloseP2PSessionWithUser() when you're done talking to a user, will free up resources under-the-hood // 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 // if the remote user tries to send data to you again, another P2PSessionRequest_t callback will be posted
virtual bool CloseP2PSessionWithUser( CSteamID steamIDRemote ) = 0; virtual bool CloseP2PSessionWithUser( CSteamID steamIDRemote ) = 0;
// call CloseP2PChannelWithUser() when you're done talking to a user on a specific channel. Once all channels // 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 // 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 // user will trigger a P2PSessionRequest_t callback
virtual bool CloseP2PChannelWithUser( CSteamID steamIDRemote, int nChannel ) = 0; virtual bool CloseP2PChannelWithUser( CSteamID steamIDRemote, int nChannel ) = 0;
// fills out P2PSessionState_t structure with details about the underlying connection to the user // fills out P2PSessionState_t structure with details about the underlying connection to the user
// should only needed for debugging purposes // should only needed for debugging purposes
// returns false if no connection exists to the specified user // returns false if no connection exists to the specified user
virtual bool GetP2PSessionState( CSteamID steamIDRemote, P2PSessionState_t *pConnectionState ) = 0; 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 // 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 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. // or to existing connections that need to automatically reconnect after this value is set.
// //
// P2P packet relay is allowed by default // P2P packet relay is allowed by default
// //
// NOTE: This function is deprecated and may be removed in a future version of the SDK. For // 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 // 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. // to this function, to prevent revealing the client's IP address top another peer.
virtual bool AllowP2PPacketRelay( bool bAllow ) = 0; virtual bool AllowP2PPacketRelay( bool bAllow ) = 0;
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
// //
// LISTEN / CONNECT connection-oriented interface functions // LISTEN / CONNECT connection-oriented interface functions
// //
// These functions are more like a client-server TCP API. One side is the "server" // 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" // and "listens" for incoming connections, which then must be "accepted." The "client"
// initiates a connection by "connecting." Sending and receiving is done through a // initiates a connection by "connecting." Sending and receiving is done through a
// connection handle. // connection handle.
// //
// For a more UDP-style interface, where you do not track connection handles but // 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. // simply send messages to a SteamID, use the UDP-style functions above.
// //
// Both methods can send both reliable and unreliable methods. // Both methods can send both reliable and unreliable methods.
// //
// These APIs are deprecated, and may be removed in a future version of the Steamworks // These APIs are deprecated, and may be removed in a future version of the Steamworks
// SDK. See ISteamNetworkingSockets. // SDK. See ISteamNetworkingSockets.
// //
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
// creates a socket and listens others to connect // creates a socket and listens others to connect
// will trigger a SocketStatusCallback_t callback on another client connecting // 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 // 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 // this can usually just be 0 unless you want multiple sets of connections
// unIP is the local IP address to bind to // unIP is the local IP address to bind to
// pass in 0 if you just want the default local IP // pass in 0 if you just want the default local IP
// unPort is the port to use // 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 // 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; virtual SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay ) = 0;
// creates a socket and begin connection to a remote destination // 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 // can connect via a known steamID (client or game server), or directly to an IP
// on success will trigger a SocketStatusCallback_t callback // 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 // 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 CreateP2PConnectionSocket( CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay ) = 0;
virtual SNetSocket_t CreateConnectionSocket( SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec ) = 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 // disconnects the connection to the socket, if any, and invalidates the handle
// any unread data on the socket will be thrown away // 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 // 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; virtual bool DestroySocket( SNetSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
// destroying a listen socket will automatically kill all the regular sockets generated from it // destroying a listen socket will automatically kill all the regular sockets generated from it
virtual bool DestroyListenSocket( SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ) = 0; virtual bool DestroyListenSocket( SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
// sending data // sending data
// must be a handle to a connected socket // 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 // 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, // use the reliable flag with caution; although the resend rate is pretty aggressive,
// it can still cause stalls in receiving data (like TCP) // it can still cause stalls in receiving data (like TCP)
virtual bool SendDataOnSocket( SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable ) = 0; virtual bool SendDataOnSocket( SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable ) = 0;
// receiving data // receiving data
// returns false if there is no data remaining // returns false if there is no data remaining
// fills out *pcubMsgSize with the size of the next message, in bytes // fills out *pcubMsgSize with the size of the next message, in bytes
virtual bool IsDataAvailableOnSocket( SNetSocket_t hSocket, uint32 *pcubMsgSize ) = 0; virtual bool IsDataAvailableOnSocket( SNetSocket_t hSocket, uint32 *pcubMsgSize ) = 0;
// fills in pubDest with the contents of the message // 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) // messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
// if *pcubMsgSize < cubDest, only partial data is written // if *pcubMsgSize < cubDest, only partial data is written
// returns false if no data is available // returns false if no data is available
virtual bool RetrieveDataFromSocket( SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0; 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 // checks for data from any socket that has been connected off this listen socket
// returns false if there is no data remaining // returns false if there is no data remaining
// fills out *pcubMsgSize with the size of the next message, in bytes // fills out *pcubMsgSize with the size of the next message, in bytes
// fills out *phSocket with the socket that data is available on // fills out *phSocket with the socket that data is available on
virtual bool IsDataAvailable( SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0; 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 // retrieves data from any socket that has been connected off this listen socket
// fills in pubDest with the contents of the message // 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) // messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
// if *pcubMsgSize < cubDest, only partial data is written // if *pcubMsgSize < cubDest, only partial data is written
// returns false if no data is available // returns false if no data is available
// fills out *phSocket with the socket that data is available on // 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; 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 // 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; 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 // 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 // *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; virtual bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, SteamIPAddress_t *pnIP, uint16 *pnPort ) = 0;
// returns true to describe how the socket ended up connecting // returns true to describe how the socket ended up connecting
virtual ESNetSocketConnectionType GetSocketConnectionType( SNetSocket_t hSocket ) = 0; virtual ESNetSocketConnectionType GetSocketConnectionType( SNetSocket_t hSocket ) = 0;
// max packet size, in bytes // max packet size, in bytes
virtual int GetMaxPacketSize( SNetSocket_t hSocket ) = 0; virtual int GetMaxPacketSize( SNetSocket_t hSocket ) = 0;
}; };
#define STEAMNETWORKING_INTERFACE_VERSION "SteamNetworking006" #define STEAMNETWORKING_INTERFACE_VERSION "SteamNetworking006"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamNetworking *SteamNetworking(); inline ISteamNetworking *SteamNetworking();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamNetworking, STEAMNETWORKING_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamNetworking, STEAMNETWORKING_INTERFACE_VERSION );
// Global accessor for the gameserver client // Global accessor for the gameserver client
inline ISteamNetworking *SteamGameServerNetworking(); inline ISteamNetworking *SteamGameServerNetworking();
STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamGameServerNetworking, STEAMNETWORKING_INTERFACE_VERSION ); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworking *, SteamGameServerNetworking, STEAMNETWORKING_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
// callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API // 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 // in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them
struct P2PSessionRequest_t struct P2PSessionRequest_t
{ {
enum { k_iCallback = k_iSteamNetworkingCallbacks + 2 }; enum { k_iCallback = k_iSteamNetworkingCallbacks + 2 };
CSteamID m_steamIDRemote; // user who wants to talk to us 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 // 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 // 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) // further attempts to send will retry making the connection (but will be dropped if we fail again)
struct P2PSessionConnectFail_t struct P2PSessionConnectFail_t
{ {
enum { k_iCallback = k_iSteamNetworkingCallbacks + 3 }; enum { k_iCallback = k_iSteamNetworkingCallbacks + 3 };
CSteamID m_steamIDRemote; // user we were sending packets to CSteamID m_steamIDRemote; // user we were sending packets to
uint8 m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble uint8 m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble
}; };
// callback notification - status of a socket has changed // callback notification - status of a socket has changed
// used as part of the CreateListenSocket() / CreateP2PConnectionSocket() // used as part of the CreateListenSocket() / CreateP2PConnectionSocket()
struct SocketStatusCallback_t struct SocketStatusCallback_t
{ {
enum { k_iCallback = k_iSteamNetworkingCallbacks + 1 }; enum { k_iCallback = k_iSteamNetworkingCallbacks + 1 };
SNetSocket_t m_hSocket; // the socket used to send/receive data to the remote host 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 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 CSteamID m_steamIDRemote; // remote steamID we have connected to, if it has one
int m_eSNetSocketState; // socket state, ESNetSocketState int m_eSNetSocketState; // socket state, ESNetSocketState
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMNETWORKING #endif // ISTEAMNETWORKING

134
sdk/steam/isteamparentalsettings.h
View file

@ -1,67 +1,67 @@
//====== Copyright � 2013-, Valve Corporation, All rights reserved. ======= //====== Copyright � 2013-, Valve Corporation, All rights reserved. =======
// //
// Purpose: Interface to Steam parental settings (Family View) // Purpose: Interface to Steam parental settings (Family View)
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMPARENTALSETTINGS_H #ifndef ISTEAMPARENTALSETTINGS_H
#define ISTEAMPARENTALSETTINGS_H #define ISTEAMPARENTALSETTINGS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// Feature types for parental settings // Feature types for parental settings
enum EParentalFeature enum EParentalFeature
{ {
k_EFeatureInvalid = 0, k_EFeatureInvalid = 0,
k_EFeatureStore = 1, k_EFeatureStore = 1,
k_EFeatureCommunity = 2, k_EFeatureCommunity = 2,
k_EFeatureProfile = 3, k_EFeatureProfile = 3,
k_EFeatureFriends = 4, k_EFeatureFriends = 4,
k_EFeatureNews = 5, k_EFeatureNews = 5,
k_EFeatureTrading = 6, k_EFeatureTrading = 6,
k_EFeatureSettings = 7, k_EFeatureSettings = 7,
k_EFeatureConsole = 8, k_EFeatureConsole = 8,
k_EFeatureBrowser = 9, k_EFeatureBrowser = 9,
k_EFeatureParentalSetup = 10, k_EFeatureParentalSetup = 10,
k_EFeatureLibrary = 11, k_EFeatureLibrary = 11,
k_EFeatureTest = 12, k_EFeatureTest = 12,
k_EFeatureSiteLicense = 13, k_EFeatureSiteLicense = 13,
k_EFeatureKioskMode_Deprecated = 14, k_EFeatureKioskMode_Deprecated = 14,
k_EFeatureBlockAlways = 15, k_EFeatureBlockAlways = 15,
k_EFeatureMax k_EFeatureMax
}; };
class ISteamParentalSettings class ISteamParentalSettings
{ {
public: public:
virtual bool BIsParentalLockEnabled() = 0; virtual bool BIsParentalLockEnabled() = 0;
virtual bool BIsParentalLockLocked() = 0; virtual bool BIsParentalLockLocked() = 0;
virtual bool BIsAppBlocked( AppId_t nAppID ) = 0; virtual bool BIsAppBlocked( AppId_t nAppID ) = 0;
virtual bool BIsAppInBlockList( AppId_t nAppID ) = 0; virtual bool BIsAppInBlockList( AppId_t nAppID ) = 0;
virtual bool BIsFeatureBlocked( EParentalFeature eFeature ) = 0; virtual bool BIsFeatureBlocked( EParentalFeature eFeature ) = 0;
virtual bool BIsFeatureInBlockList( EParentalFeature eFeature ) = 0; virtual bool BIsFeatureInBlockList( EParentalFeature eFeature ) = 0;
}; };
#define STEAMPARENTALSETTINGS_INTERFACE_VERSION "STEAMPARENTALSETTINGS_INTERFACE_VERSION001" #define STEAMPARENTALSETTINGS_INTERFACE_VERSION "STEAMPARENTALSETTINGS_INTERFACE_VERSION001"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamParentalSettings *SteamParentalSettings(); inline ISteamParentalSettings *SteamParentalSettings();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamParentalSettings *, SteamParentalSettings, STEAMPARENTALSETTINGS_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamParentalSettings *, SteamParentalSettings, STEAMPARENTALSETTINGS_INTERFACE_VERSION );
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Callback for querying UGC // Purpose: Callback for querying UGC
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamParentalSettingsChanged_t struct SteamParentalSettingsChanged_t
{ {
enum { k_iCallback = k_ISteamParentalSettingsCallbacks + 1 }; enum { k_iCallback = k_ISteamParentalSettingsCallbacks + 1 };
}; };
#endif // ISTEAMPARENTALSETTINGS_H #endif // ISTEAMPARENTALSETTINGS_H

178
sdk/steam/isteamps3overlayrenderer.h
View file

@ -1,91 +1,91 @@
//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2010, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface the game must provide Steam with on PS3 in order for the // Purpose: interface the game must provide Steam with on PS3 in order for the
// Steam overlay to render. // Steam overlay to render.
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMPS3OVERLAYRENDERER_H #ifndef ISTEAMPS3OVERLAYRENDERER_H
#define ISTEAMPS3OVERLAYRENDERER_H #define ISTEAMPS3OVERLAYRENDERER_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "cell/pad.h" #include "cell/pad.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Enum for supported gradient directions // Purpose: Enum for supported gradient directions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum EOverlayGradientDirection enum EOverlayGradientDirection
{ {
k_EOverlayGradientHorizontal = 1, k_EOverlayGradientHorizontal = 1,
k_EOverlayGradientVertical = 2, k_EOverlayGradientVertical = 2,
k_EOverlayGradientNone = 3, k_EOverlayGradientNone = 3,
}; };
// Helpers for fetching individual color components from ARGB packed DWORD colors Steam PS3 overlay renderer uses. // Helpers for fetching individual color components from ARGB packed DWORD colors Steam PS3 overlay renderer uses.
#define STEAM_COLOR_RED( color ) \ #define STEAM_COLOR_RED( color ) \
(int)(((color)>>16)&0xff) (int)(((color)>>16)&0xff)
#define STEAM_COLOR_GREEN( color ) \ #define STEAM_COLOR_GREEN( color ) \
(int)(((color)>>8)&0xff) (int)(((color)>>8)&0xff)
#define STEAM_COLOR_BLUE( color ) \ #define STEAM_COLOR_BLUE( color ) \
(int)((color)&0xff) (int)((color)&0xff)
#define STEAM_COLOR_ALPHA( color ) \ #define STEAM_COLOR_ALPHA( color ) \
(int)(((color)>>24)&0xff) (int)(((color)>>24)&0xff)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Interface the game must expose to Steam for rendering // Purpose: Interface the game must expose to Steam for rendering
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamPS3OverlayRenderHost class ISteamPS3OverlayRenderHost
{ {
public: public:
// Interface for game engine to implement which Steam requires to render. // 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. // 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; 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. // 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; 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 // Delete a texture Steam previously uploaded
virtual void DeleteTexture( int32 iTextureID ) = 0; virtual void DeleteTexture( int32 iTextureID ) = 0;
// Delete all previously uploaded textures // Delete all previously uploaded textures
virtual void DeleteAllTextures() = 0; virtual void DeleteAllTextures() = 0;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Interface Steam exposes for the game to tell it when to render, etc. // Purpose: Interface Steam exposes for the game to tell it when to render, etc.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamPS3OverlayRender class ISteamPS3OverlayRender
{ {
public: public:
// Call once at startup to initialize the Steam overlay and pass it your host interface ptr // 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; 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) // 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; virtual void Render() = 0;
// Call this everytime you read input on PS3. // Call this everytime you read input on PS3.
// //
// If this returns true, then the overlay is active and has consumed the input, your game // 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 // should then ignore all the input until BHandleCellPadData once again returns false, which
// will mean the overlay is deactivated. // will mean the overlay is deactivated.
virtual bool BHandleCellPadData( const CellPadData &padData ) = 0; virtual bool BHandleCellPadData( const CellPadData &padData ) = 0;
// Call this if you detect no controllers connected or that the XMB is intercepting input // 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 // This is important to clear input state for the overlay, so keys left down during XMB activation
// are not continued to be processed. // are not continued to be processed.
virtual bool BResetInputState() = 0; virtual bool BResetInputState() = 0;
}; };
#endif // ISTEAMPS3OVERLAYRENDERER_H #endif // ISTEAMPS3OVERLAYRENDERER_H

1326
sdk/steam/isteamremotestorage.h
View file

File diff suppressed because it is too large Load diff

244
sdk/steam/isteamscreenshots.h
View file

@ -1,122 +1,122 @@
//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: public interface to user remote file storage in Steam // Purpose: public interface to user remote file storage in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMSCREENSHOTS_H #ifndef ISTEAMSCREENSHOTS_H
#define ISTEAMSCREENSHOTS_H #define ISTEAMSCREENSHOTS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
const uint32 k_nScreenshotMaxTaggedUsers = 32; const uint32 k_nScreenshotMaxTaggedUsers = 32;
const uint32 k_nScreenshotMaxTaggedPublishedFiles = 32; const uint32 k_nScreenshotMaxTaggedPublishedFiles = 32;
const int k_cubUFSTagTypeMax = 255; const int k_cubUFSTagTypeMax = 255;
const int k_cubUFSTagValueMax = 255; const int k_cubUFSTagValueMax = 255;
// Required with of a thumbnail provided to AddScreenshotToLibrary. If you do not provide a thumbnail // Required with of a thumbnail provided to AddScreenshotToLibrary. If you do not provide a thumbnail
// one will be generated. // one will be generated.
const int k_ScreenshotThumbWidth = 200; const int k_ScreenshotThumbWidth = 200;
// Handle is valid for the lifetime of your process and no longer // Handle is valid for the lifetime of your process and no longer
typedef uint32 ScreenshotHandle; typedef uint32 ScreenshotHandle;
#define INVALID_SCREENSHOT_HANDLE 0 #define INVALID_SCREENSHOT_HANDLE 0
enum EVRScreenshotType enum EVRScreenshotType
{ {
k_EVRScreenshotType_None = 0, k_EVRScreenshotType_None = 0,
k_EVRScreenshotType_Mono = 1, k_EVRScreenshotType_Mono = 1,
k_EVRScreenshotType_Stereo = 2, k_EVRScreenshotType_Stereo = 2,
k_EVRScreenshotType_MonoCubemap = 3, k_EVRScreenshotType_MonoCubemap = 3,
k_EVRScreenshotType_MonoPanorama = 4, k_EVRScreenshotType_MonoPanorama = 4,
k_EVRScreenshotType_StereoPanorama = 5 k_EVRScreenshotType_StereoPanorama = 5
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for adding screenshots to the user's screenshot library // Purpose: Functions for adding screenshots to the user's screenshot library
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamScreenshots class ISteamScreenshots
{ {
public: public:
// Writes a screenshot to the user's screenshot library given the raw image data, which must be in RGB format. // 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. // 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; 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 // 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. // 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. // 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. // JPEG, TGA, and PNG formats are supported.
virtual ScreenshotHandle AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight ) = 0; 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. // 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; 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, // 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 // 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. // in response.
virtual void HookScreenshots( bool bHook ) = 0; virtual void HookScreenshots( bool bHook ) = 0;
// Sets metadata about a screenshot's location (for example, the name of the map) // Sets metadata about a screenshot's location (for example, the name of the map)
virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0; virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0;
// Tags a user as being visible in the screenshot // Tags a user as being visible in the screenshot
virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0; virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0;
// Tags a published file as being visible in the screenshot // Tags a published file as being visible in the screenshot
virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0; virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0;
// Returns true if the app has hooked the screenshot // Returns true if the app has hooked the screenshot
virtual bool IsScreenshotsHooked() = 0; virtual bool IsScreenshotsHooked() = 0;
// Adds a VR screenshot to the user's screenshot library from disk in the supported type. // 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 // pchFilename should be the normal 2D image used in the library view
// pchVRFilename should contain the image that matches the correct type // 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. // 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. // JPEG, TGA, and PNG formats are supported.
virtual ScreenshotHandle AddVRScreenshotToLibrary( EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename ) = 0; virtual ScreenshotHandle AddVRScreenshotToLibrary( EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename ) = 0;
}; };
#define STEAMSCREENSHOTS_INTERFACE_VERSION "STEAMSCREENSHOTS_INTERFACE_VERSION003" #define STEAMSCREENSHOTS_INTERFACE_VERSION "STEAMSCREENSHOTS_INTERFACE_VERSION003"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamScreenshots *SteamScreenshots(); inline ISteamScreenshots *SteamScreenshots();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamScreenshots *, SteamScreenshots, STEAMSCREENSHOTS_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamScreenshots *, SteamScreenshots, STEAMSCREENSHOTS_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Screenshot successfully written or otherwise added to the library // Purpose: Screenshot successfully written or otherwise added to the library
// and can now be tagged // and can now be tagged
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct ScreenshotReady_t struct ScreenshotReady_t
{ {
enum { k_iCallback = k_iSteamScreenshotsCallbacks + 1 }; enum { k_iCallback = k_iSteamScreenshotsCallbacks + 1 };
ScreenshotHandle m_hLocal; ScreenshotHandle m_hLocal;
EResult m_eResult; EResult m_eResult;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Screenshot has been requested by the user. Only sent if // Purpose: Screenshot has been requested by the user. Only sent if
// HookScreenshots() has been called, in which case Steam will not take // HookScreenshots() has been called, in which case Steam will not take
// the screenshot itself. // the screenshot itself.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct ScreenshotRequested_t struct ScreenshotRequested_t
{ {
enum { k_iCallback = k_iSteamScreenshotsCallbacks + 2 }; enum { k_iCallback = k_iSteamScreenshotsCallbacks + 2 };
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMSCREENSHOTS_H #endif // ISTEAMSCREENSHOTS_H

82
sdk/steam/isteamscreenshots001.h
View file

@ -1,42 +1,42 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: public interface to user remote file storage in Steam // Purpose: public interface to user remote file storage in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMSCREENSHOTS001_H #ifndef ISTEAMSCREENSHOTS001_H
#define ISTEAMSCREENSHOTS001_H #define ISTEAMSCREENSHOTS001_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for adding screenshots to the user's screenshot library // Purpose: Functions for adding screenshots to the user's screenshot library
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamScreenshots001 class ISteamScreenshots001
{ {
public: public:
// Writes a screenshot to the user's screenshot library given the raw image data, which must be in RGB format. // 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. // 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; 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 // 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. // 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. // 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 AddScreenshotToLibrary( const char *pchJpegOrTGAFilename, const char *pchJpegOrTGAThumbFilename, int nWidth, int nHeight ) = 0; virtual ScreenshotHandle AddScreenshotToLibrary( const char *pchJpegOrTGAFilename, const char *pchJpegOrTGAThumbFilename, 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. // 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; 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, // 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 // 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. // in response.
virtual void HookScreenshots( bool bHook ) = 0; virtual void HookScreenshots( bool bHook ) = 0;
// Sets metadata about a screenshot's location (for example, the name of the map) // Sets metadata about a screenshot's location (for example, the name of the map)
virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0; virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0;
// Tags a user as being visible in the screenshot // Tags a user as being visible in the screenshot
virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0; virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0;
}; };
#endif // ISTEAMSCREENSHOTS001_H #endif // ISTEAMSCREENSHOTS001_H

90
sdk/steam/isteamscreenshots002.h
View file

@ -1,46 +1,46 @@
//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: public interface to user remote file storage in Steam // Purpose: public interface to user remote file storage in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMSCREENSHOTS002_H #ifndef ISTEAMSCREENSHOTS002_H
#define ISTEAMSCREENSHOTS002_H #define ISTEAMSCREENSHOTS002_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for adding screenshots to the user's screenshot library // Purpose: Functions for adding screenshots to the user's screenshot library
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamScreenshots002 class ISteamScreenshots002
{ {
public: public:
// Writes a screenshot to the user's screenshot library given the raw image data, which must be in RGB format. // 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. // 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; 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 // 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. // 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. // 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. // JPEG, TGA, and PNG formats are supported.
virtual ScreenshotHandle AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight ) = 0; 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. // 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; 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, // 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 // 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. // in response.
virtual void HookScreenshots( bool bHook ) = 0; virtual void HookScreenshots( bool bHook ) = 0;
// Sets metadata about a screenshot's location (for example, the name of the map) // Sets metadata about a screenshot's location (for example, the name of the map)
virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0; virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0;
// Tags a user as being visible in the screenshot // Tags a user as being visible in the screenshot
virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0; virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0;
// Tags a published file as being visible in the screenshot // Tags a published file as being visible in the screenshot
virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0; virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0;
}; };
#endif // ISTEAMSCREENSHOTS002_H #endif // ISTEAMSCREENSHOTS002_H

136
sdk/steam/isteamtimeline001.h
View file

@ -1,69 +1,69 @@
//====== Copyright © Valve Corporation, All rights reserved. ======= //====== Copyright © Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to Steam Timeline // Purpose: interface to Steam Timeline
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMTIMELINE001_H #ifndef ISTEAMTIMELINE001_H
#define ISTEAMTIMELINE001_H #define ISTEAMTIMELINE001_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Steam Timeline API // Purpose: Steam Timeline API
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamTimeline001 class ISteamTimeline001
{ {
public: public:
// Sets a description for the current game state in the timeline. These help the user to find specific // 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 // moments in the timeline when saving clips. Setting a new state description replaces any previous
// description. // description.
// //
// Examples could include: // Examples could include:
// * Where the user is in the world in a single player game // * Where the user is in the world in a single player game
// * Which round is happening in a multiplayer game // * Which round is happening in a multiplayer game
// * The current score for a sports game // * The current score for a sports game
// //
// Parameters: // Parameters:
// - pchDescription: provide a localized string in the language returned by SteamUtils()->GetSteamUILanguage() // - 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 // - flTimeDelta: The time offset in seconds to apply to this event. Negative times indicate an
// event that happened in the past. // event that happened in the past.
virtual void SetTimelineStateDescription( const char *pchDescription, float flTimeDelta ) = 0; virtual void SetTimelineStateDescription( const char *pchDescription, float flTimeDelta ) = 0;
virtual void ClearTimelineStateDescription( 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 // 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 // to complete, depending on the value passed in flDurationSeconds
// //
// Examples could include: // Examples could include:
// * a boss battle // * a boss battle
// * a cut scene // * a cut scene
// * a large team fight // * a large team fight
// * picking up a new weapon or ammunition // * picking up a new weapon or ammunition
// * scoring a goal // * scoring a goal
// //
// Parameters: // Parameters:
// //
// - pchIcon: specify the name of the icon uploaded through the Steamworks Partner Site for your title // - 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_ // or one of the provided icons that start with steam_
// - pchTitle & pchDescription: provide a localized string in the language returned by // - pchTitle & pchDescription: provide a localized string in the language returned by
// SteamUtils()->GetSteamUILanguage() // SteamUtils()->GetSteamUILanguage()
// - unPriority: specify how important this range is compared to other markers provided by the game. // - 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 // Ranges with larger priority values will be displayed more prominently in the UI. This value
// may be between 0 and k_unMaxTimelinePriority. // may be between 0 and k_unMaxTimelinePriority.
// - flStartOffsetSeconds: The time that this range started relative to now. Negative times // - flStartOffsetSeconds: The time that this range started relative to now. Negative times
// indicate an event that happened in the past. // indicate an event that happened in the past.
// - flDurationSeconds: How long the time range should be in seconds. For instantaneous events, this // - flDurationSeconds: How long the time range should be in seconds. For instantaneous events, this
// should be 0 // should be 0
// - ePossibleClip: By setting this parameter to Featured or Standard, the game indicates to Steam that it // - 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 // 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. // suggested clip will be for a short time before and after the event itself.
virtual void AddTimelineEvent_old( const char *pchIcon, const char *pchTitle, const char *pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip ) = 0; virtual void AddTimelineEvent_old( 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 // Changes the color of the timeline bar. See ETimelineGameMode comments for how to use each value
virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0; virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0;
}; };
#endif // ISTEAMTIMELINE001_H #endif // ISTEAMTIMELINE001_H

1280
sdk/steam/isteamugc.h
View file

File diff suppressed because it is too large Load diff

126
sdk/steam/isteamunifiedmessages.h
View file

@ -1,63 +1,63 @@
//====== Copyright � 1996-2007, Valve Corporation, All rights reserved. ======= //====== Copyright � 1996-2007, Valve Corporation, All rights reserved. =======
// //
// Purpose: Interface to unified messages client // Purpose: Interface to unified messages client
// //
// You should not need to use this interface except if your product is using a language other than C++. // You should not need to use this interface except if your product is using a language other than C++.
// Contact your Steam Tech contact for more details. // Contact your Steam Tech contact for more details.
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMUNIFIEDMESSAGES_H #ifndef ISTEAMUNIFIEDMESSAGES_H
#define ISTEAMUNIFIEDMESSAGES_H #define ISTEAMUNIFIEDMESSAGES_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
typedef uint64 ClientUnifiedMessageHandle; typedef uint64 ClientUnifiedMessageHandle;
class ISteamUnifiedMessages class ISteamUnifiedMessages
{ {
public: public:
static const ClientUnifiedMessageHandle k_InvalidUnifiedMessageHandle = 0; static const ClientUnifiedMessageHandle k_InvalidUnifiedMessageHandle = 0;
// Sends a service method (in binary serialized form) using the Steam Client. // Sends a service method (in binary serialized form) using the Steam Client.
// Returns a unified message handle (k_InvalidUnifiedMessageHandle if could not send the message). // Returns a unified message handle (k_InvalidUnifiedMessageHandle if could not send the message).
virtual ClientUnifiedMessageHandle SendMethod( const char *pchServiceMethod, const void *pRequestBuffer, uint32 unRequestBufferSize, uint64 unContext ) = 0; virtual ClientUnifiedMessageHandle SendMethod( const char *pchServiceMethod, const void *pRequestBuffer, uint32 unRequestBufferSize, uint64 unContext ) = 0;
// Gets the size of the response and the EResult. Returns false if the response is not ready yet. // Gets the size of the response and the EResult. Returns false if the response is not ready yet.
virtual bool GetMethodResponseInfo( ClientUnifiedMessageHandle hHandle, uint32 *punResponseSize, EResult *peResult ) = 0; virtual bool GetMethodResponseInfo( ClientUnifiedMessageHandle hHandle, uint32 *punResponseSize, EResult *peResult ) = 0;
// Gets a response in binary serialized form (and optionally release the corresponding allocated memory). // Gets a response in binary serialized form (and optionally release the corresponding allocated memory).
virtual bool GetMethodResponseData( ClientUnifiedMessageHandle hHandle, void *pResponseBuffer, uint32 unResponseBufferSize, bool bAutoRelease ) = 0; virtual bool GetMethodResponseData( ClientUnifiedMessageHandle hHandle, void *pResponseBuffer, uint32 unResponseBufferSize, bool bAutoRelease ) = 0;
// Releases the message and its corresponding allocated memory. // Releases the message and its corresponding allocated memory.
virtual bool ReleaseMethod( ClientUnifiedMessageHandle hHandle ) = 0; virtual bool ReleaseMethod( ClientUnifiedMessageHandle hHandle ) = 0;
// Sends a service notification (in binary serialized form) using the Steam Client. // Sends a service notification (in binary serialized form) using the Steam Client.
// Returns true if the notification was sent successfully. // Returns true if the notification was sent successfully.
virtual bool SendNotification( const char *pchServiceNotification, const void *pNotificationBuffer, uint32 unNotificationBufferSize ) = 0; virtual bool SendNotification( const char *pchServiceNotification, const void *pNotificationBuffer, uint32 unNotificationBufferSize ) = 0;
}; };
#define STEAMUNIFIEDMESSAGES_INTERFACE_VERSION "STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001" #define STEAMUNIFIEDMESSAGES_INTERFACE_VERSION "STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001"
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error isteamclient.h must be included #error isteamclient.h must be included
#endif #endif
struct SteamUnifiedMessagesSendMethodResult_t struct SteamUnifiedMessagesSendMethodResult_t
{ {
enum { k_iCallback = k_iClientUnifiedMessagesCallbacks + 1 }; enum { k_iCallback = k_iClientUnifiedMessagesCallbacks + 1 };
ClientUnifiedMessageHandle m_hHandle; // The handle returned by SendMethod(). ClientUnifiedMessageHandle m_hHandle; // The handle returned by SendMethod().
uint64 m_unContext; // Context provided when calling SendMethod(). uint64 m_unContext; // Context provided when calling SendMethod().
EResult m_eResult; // The result of the method call. EResult m_eResult; // The result of the method call.
uint32 m_unResponseSize; // The size of the response. uint32 m_unResponseSize; // The size of the response.
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMUNIFIEDMESSAGES_H #endif // ISTEAMUNIFIEDMESSAGES_H

870
sdk/steam/isteamuser.h
View file

@ -1,435 +1,435 @@
//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to user account information in Steam // Purpose: interface to user account information in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMUSER_H #ifndef ISTEAMUSER_H
#define ISTEAMUSER_H #define ISTEAMUSER_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for accessing and manipulating a steam account // Purpose: Functions for accessing and manipulating a steam account
// associated with one client instance // associated with one client instance
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamUser class ISteamUser
{ {
public: public:
// returns the HSteamUser this interface represents // returns the HSteamUser this interface represents
// this is only used internally by the API, and by a few select interfaces that support multi-user // this is only used internally by the API, and by a few select interfaces that support multi-user
virtual HSteamUser GetHSteamUser() = 0; virtual HSteamUser GetHSteamUser() = 0;
// returns true if the Steam client current has a live connection to the Steam servers. // 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. // 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. // The Steam client will automatically be trying to recreate the connection as often as possible.
virtual bool BLoggedOn() = 0; virtual bool BLoggedOn() = 0;
// returns the CSteamID of the account currently logged into the Steam client // 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 // 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; virtual CSteamID GetSteamID() = 0;
// Multiplayer Authentication functions // Multiplayer Authentication functions
// InitiateGameConnection() starts the state machine for authenticating the game client with the game server // 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 // It is the client portion of a three-way handshake between the client, the game server, and the steam servers
// //
// Parameters: // Parameters:
// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token. // 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. // 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 // 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( <appID> ) // CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
// uint32 unIPServer, uint16 usPortServer - the IP address of the game server // 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) // 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 // 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. // The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0; virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
// notify of disconnect // notify of disconnect
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call // needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0; virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
// Legacy functions // Legacy functions
// used by only a few games to track usage events // used by only a few games to track usage events
virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0; 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. // 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\<SteamID>\<AppID>\local" // this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local"
virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0; virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0;
// Starts voice recording. Once started, use GetVoice() to get the data // Starts voice recording. Once started, use GetVoice() to get the data
virtual void StartVoiceRecording( ) = 0; virtual void StartVoiceRecording( ) = 0;
// Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for // 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 // a little bit after this function is called. GetVoice() should continue to be called until it returns
// k_eVoiceResultNotRecording // k_eVoiceResultNotRecording
virtual void StopVoiceRecording( ) = 0; virtual void StopVoiceRecording( ) = 0;
// Determine the size of captured audio data that is available from GetVoice. // Determine the size of captured audio data that is available from GetVoice.
// Most applications will only use compressed data and should ignore the other // Most applications will only use compressed data and should ignore the other
// parameters, which exist primarily for backwards compatibility. See comments // parameters, which exist primarily for backwards compatibility. See comments
// below for further explanation of "uncompressed" data. // below for further explanation of "uncompressed" data.
virtual EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0; 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 // 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 // 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, // may have been run through preprocessing filters and/or had silence removed,
// so the uncompressed audio could have a shorter duration than you expect. // 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 // There may be no data at all during long periods of silence. Also, fetching
// uncompressed audio will cause GetVoice to discard any leftover compressed // uncompressed audio will cause GetVoice to discard any leftover compressed
// audio, so you must fetch both types at once. Finally, GetAvailableVoice is // audio, so you must fetch both types at once. Finally, GetAvailableVoice is
// not precisely accurate when the uncompressed size is requested. So if you // not precisely accurate when the uncompressed size is requested. So if you
// really need to use uncompressed audio, you should call GetVoice frequently // really need to use uncompressed audio, you should call GetVoice frequently
// with two very large (20kb+) output buffers instead of trying to allocate // with two very large (20kb+) output buffers instead of trying to allocate
// perfectly-sized buffers. But most applications should ignore all of these // perfectly-sized buffers. But most applications should ignore all of these
// details and simply leave the "uncompressed" parameters as NULL/zero. // details and simply leave the "uncompressed" parameters as NULL/zero.
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Read captured audio data from the microphone buffer. This should be called // 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 // 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 // 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 and should pass NULL/zero for the "uncompressed" parameters.
// Compressed data can be transmitted by your application and decoded into raw // Compressed data can be transmitted by your application and decoded into raw
// using the DecompressVoice function below. // 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; 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 // 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 // raw single-channel 16-bit PCM audio. The decoder supports any sample rate
// from 11025 to 48000; see GetVoiceOptimalSampleRate() below for details. // from 11025 to 48000; see GetVoiceOptimalSampleRate() below for details.
// If the output buffer is not large enough, then *nBytesWritten will be set // If the output buffer is not large enough, then *nBytesWritten will be set
// to the required buffer size, and k_EVoiceResultBufferTooSmall is returned. // to the required buffer size, and k_EVoiceResultBufferTooSmall is returned.
// It is suggested to start with a 20kb buffer and reallocate as necessary. // 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; 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 returns the native sample rate of the Steam voice decompressor; using
// this sample rate for DecompressVoice will perform the least CPU processing. // this sample rate for DecompressVoice will perform the least CPU processing.
// However, the final audio quality will depend on how well the audio device // 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. // (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 // 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, // this function and use the native sample rate of your audio output device,
// which is usually 48000 or 44100. // which is usually 48000 or 44100.
virtual uint32 GetVoiceOptimalSampleRate() = 0; virtual uint32 GetVoiceOptimalSampleRate() = 0;
// Retrieve ticket to be sent to the entity who wishes to authenticate you. // Retrieve ticket to be sent to the entity who wishes to authenticate you.
// pcbTicket retrieves the length of the actual ticket. // 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 // 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 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 // 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 // not to be used for "ISteamUserAuth\AuthenticateUserTicket" - it will fail
virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity ) = 0; virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity ) = 0;
// Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket" // 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 // 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 // the ticket will be returned in callback GetTicketForWebApiResponse_t
virtual HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity ) = 0; virtual HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity ) = 0;
// Authenticate ticket from entity steamID to be sure it is valid and isnt reused // 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 ) // 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; 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 // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
virtual void EndAuthSession( CSteamID steamID ) = 0; 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 // 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; virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
// After receiving a user's authentication data, and passing it to BeginAuthSession, use this function // 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. // to determine if the user owns downloadable content specified by the provided AppID.
virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0; 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 // 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. // (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
virtual bool BIsBehindNAT() = 0; virtual bool BIsBehindNAT() = 0;
// set data to be replicated to friends so that they can join your game // 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 // 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 // uint32 unIPServer, uint16 usPortServer - the IP address of the game server
virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0; virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0;
// Requests a ticket encrypted with an app specific shared key // Requests a ticket encrypted with an app specific shared key
// pDataToInclude, cbDataToInclude will be encrypted into the ticket // pDataToInclude, cbDataToInclude will be encrypted into the ticket
// ( This is asynchronous, you must wait for the ticket to be completed by the server ) // ( This is asynchronous, you must wait for the ticket to be completed by the server )
STEAM_CALL_RESULT( EncryptedAppTicketResponse_t ) STEAM_CALL_RESULT( EncryptedAppTicketResponse_t )
virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0; virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0;
// Retrieves a finished ticket. // Retrieves a finished ticket.
// If no ticket is available, or your buffer is too small, returns false. // 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 // 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 // (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 // 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. // is available, *pcbTicket will contain the size needed, otherwise it will be zero.
virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0; virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
// Trading Card badges data access // Trading Card badges data access
// if you only have one set of cards, the series will be 1 // 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) // 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; virtual int GetGameBadgeLevel( int nSeries, bool bFoil ) = 0;
// gets the Steam Level of the user, as shown on their profile // gets the Steam Level of the user, as shown on their profile
virtual int GetPlayerSteamLevel() = 0; virtual int GetPlayerSteamLevel() = 0;
// Requests a URL which authenticates an in-game browser for store check-out, // 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 // and then redirects to the specified URL. As long as the in-game browser
// accepts and handles session cookies, Steam microtransaction checkout pages // accepts and handles session cookies, Steam microtransaction checkout pages
// will automatically recognize the user instead of presenting a login page. // will automatically recognize the user instead of presenting a login page.
// The result of this API call will be a StoreAuthURLResponse_t callback. // 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, // 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, // 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. // 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, // 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. // so it would be a good idea to request and visit a new auth URL every 12 hours.
STEAM_CALL_RESULT( StoreAuthURLResponse_t ) STEAM_CALL_RESULT( StoreAuthURLResponse_t )
virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0; virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0;
// gets whether the users phone number is verified // gets whether the users phone number is verified
virtual bool BIsPhoneVerified() = 0; virtual bool BIsPhoneVerified() = 0;
// gets whether the user has two factor enabled on their account // gets whether the user has two factor enabled on their account
virtual bool BIsTwoFactorEnabled() = 0; virtual bool BIsTwoFactorEnabled() = 0;
// gets whether the users phone number is identifying // gets whether the users phone number is identifying
virtual bool BIsPhoneIdentifying() = 0; virtual bool BIsPhoneIdentifying() = 0;
// gets whether the users phone number is awaiting (re)verification // gets whether the users phone number is awaiting (re)verification
virtual bool BIsPhoneRequiringVerification() = 0; virtual bool BIsPhoneRequiringVerification() = 0;
STEAM_CALL_RESULT( MarketEligibilityResponse_t ) STEAM_CALL_RESULT( MarketEligibilityResponse_t )
virtual SteamAPICall_t GetMarketEligibility() = 0; virtual SteamAPICall_t GetMarketEligibility() = 0;
// Retrieves anti indulgence / duration control for current user // Retrieves anti indulgence / duration control for current user
STEAM_CALL_RESULT( DurationControl_t ) STEAM_CALL_RESULT( DurationControl_t )
virtual SteamAPICall_t GetDurationControl() = 0; virtual SteamAPICall_t GetDurationControl() = 0;
// Advise steam china duration control system about the online state of the game. // 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 // This will prevent offline gameplay time from counting against a user's
// playtime limits. // playtime limits.
virtual bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) = 0; virtual bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) = 0;
}; };
#define STEAMUSER_INTERFACE_VERSION "SteamUser023" #define STEAMUSER_INTERFACE_VERSION "SteamUser023"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamUser *SteamUser(); inline ISteamUser *SteamUser();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUser *, SteamUser, STEAMUSER_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUser *, SteamUser, STEAMUSER_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Called when an authenticated connection to the Steam back-end has been established. // 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. // 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 // 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 // only be seen if the user has dropped connection due to a networking issue
// or a Steam server update. // or a Steam server update.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamServersConnected_t struct SteamServersConnected_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 1 }; enum { k_iCallback = k_iSteamUserCallbacks + 1 };
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when a connection attempt has failed // Purpose: called when a connection attempt has failed
// this will occur periodically if the Steam client is not connected, // this will occur periodically if the Steam client is not connected,
// and has failed in it's retry to establish a connection // and has failed in it's retry to establish a connection
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamServerConnectFailure_t struct SteamServerConnectFailure_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 2 }; enum { k_iCallback = k_iSteamUserCallbacks + 2 };
EResult m_eResult; EResult m_eResult;
bool m_bStillRetrying; bool m_bStillRetrying;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called if the client has lost connection to the Steam servers // 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 // real-time services will be disabled until a matching SteamServersConnected_t has been posted
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamServersDisconnected_t struct SteamServersDisconnected_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 3 }; enum { k_iCallback = k_iSteamUserCallbacks + 3 };
EResult m_eResult; EResult m_eResult;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server, // 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. // which it may be in the process of or already connected to.
// The game client should immediately disconnect upon receiving this message. // 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. // This can usually occur if the user doesn't have rights to play on the game server.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct ClientGameServerDeny_t struct ClientGameServerDeny_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 13 }; enum { k_iCallback = k_iSteamUserCallbacks + 13 };
uint32 m_uAppID; uint32 m_uAppID;
uint32 m_unGameServerIP; uint32 m_unGameServerIP;
uint16 m_usGameServerPort; uint16 m_usGameServerPort;
uint16 m_bSecure; uint16 m_bSecure;
uint32 m_uReason; uint32 m_uReason;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks) // 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. // 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. // This usually occurs in the rare event the Steam client has some kind of fatal error.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct IPCFailure_t struct IPCFailure_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 17 }; enum { k_iCallback = k_iSteamUserCallbacks + 17 };
enum EFailureType enum EFailureType
{ {
k_EFailureFlushedCallbackQueue, k_EFailureFlushedCallbackQueue,
k_EFailurePipeFail, k_EFailurePipeFail,
}; };
uint8 m_eFailureType; uint8 m_eFailureType;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Signaled whenever licenses change // Purpose: Signaled whenever licenses change
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct LicensesUpdated_t struct LicensesUpdated_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 25 }; enum { k_iCallback = k_iSteamUserCallbacks + 25 };
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// callback for BeginAuthSession // callback for BeginAuthSession
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct ValidateAuthTicketResponse_t struct ValidateAuthTicketResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 43 }; enum { k_iCallback = k_iSteamUserCallbacks + 43 };
CSteamID m_SteamID; CSteamID m_SteamID;
EAuthSessionResponse m_eAuthSessionResponse; EAuthSessionResponse m_eAuthSessionResponse;
CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when a user has responded to a microtransaction authorization request // Purpose: called when a user has responded to a microtransaction authorization request
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct MicroTxnAuthorizationResponse_t struct MicroTxnAuthorizationResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 52 }; enum { k_iCallback = k_iSteamUserCallbacks + 52 };
uint32 m_unAppID; // AppID for this microtransaction uint32 m_unAppID; // AppID for this microtransaction
uint64 m_ulOrderID; // OrderID provided for the microtransaction uint64 m_ulOrderID; // OrderID provided for the microtransaction
uint8 m_bAuthorized; // if user authorized transaction uint8 m_bAuthorized; // if user authorized transaction
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Result from RequestEncryptedAppTicket // Purpose: Result from RequestEncryptedAppTicket
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct EncryptedAppTicketResponse_t struct EncryptedAppTicketResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 54 }; enum { k_iCallback = k_iSteamUserCallbacks + 54 };
EResult m_eResult; EResult m_eResult;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// callback for GetAuthSessionTicket // callback for GetAuthSessionTicket
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GetAuthSessionTicketResponse_t struct GetAuthSessionTicketResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 63 }; enum { k_iCallback = k_iSteamUserCallbacks + 63 };
HAuthTicket m_hAuthTicket; HAuthTicket m_hAuthTicket;
EResult m_eResult; EResult m_eResult;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: sent to your game in response to a steam://gamewebcallback/ command // Purpose: sent to your game in response to a steam://gamewebcallback/ command
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GameWebCallback_t struct GameWebCallback_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 64 }; enum { k_iCallback = k_iSteamUserCallbacks + 64 };
char m_szURL[256]; char m_szURL[256];
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL // Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct StoreAuthURLResponse_t struct StoreAuthURLResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 65 }; enum { k_iCallback = k_iSteamUserCallbacks + 65 };
char m_szURL[512]; char m_szURL[512];
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: sent in response to ISteamUser::GetMarketEligibility // Purpose: sent in response to ISteamUser::GetMarketEligibility
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct MarketEligibilityResponse_t struct MarketEligibilityResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 66 }; enum { k_iCallback = k_iSteamUserCallbacks + 66 };
bool m_bAllowed; bool m_bAllowed;
EMarketNotAllowedReasonFlags m_eNotAllowedReason; EMarketNotAllowedReasonFlags m_eNotAllowedReason;
RTime32 m_rtAllowedAtTime; 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_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 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 // Purpose: sent for games with enabled anti indulgence / duration control, for
// enabled users. Lets the game know whether the user can keep playing or // 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. // whether the game should exit, and returns info about remaining gameplay time.
// //
// This callback is fired asynchronously in response to timers triggering. // This callback is fired asynchronously in response to timers triggering.
// It is also fired in response to calls to GetDurationControl(). // It is also fired in response to calls to GetDurationControl().
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct DurationControl_t struct DurationControl_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 67 }; enum { k_iCallback = k_iSteamUserCallbacks + 67 };
EResult m_eResult; // result of call (always k_EResultOK for asynchronous timer-based notifications) EResult m_eResult; // result of call (always k_EResultOK for asynchronous timer-based notifications)
AppId_t m_appid; // appid generating playtime AppId_t m_appid; // appid generating playtime
bool m_bApplicable; // is duration control applicable to user + game combination 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 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) 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) 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_csecsToday; // playtime on current calendar day
int32 m_csecsRemaining; // playtime remaining until the user hits a regulatory limit int32 m_csecsRemaining; // playtime remaining until the user hits a regulatory limit
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// callback for GetTicketForWebApi // callback for GetTicketForWebApi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GetTicketForWebApiResponse_t struct GetTicketForWebApiResponse_t
{ {
enum { k_iCallback = k_iSteamUserCallbacks + 68 }; enum { k_iCallback = k_iSteamUserCallbacks + 68 };
HAuthTicket m_hAuthTicket; HAuthTicket m_hAuthTicket;
EResult m_eResult; EResult m_eResult;
int m_cubTicket; int m_cubTicket;
static const int k_nCubTicketMaxLength = 2560; static const int k_nCubTicketMaxLength = 2560;
uint8 m_rgubTicket[k_nCubTicketMaxLength]; uint8 m_rgubTicket[k_nCubTicketMaxLength];
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMUSER_H #endif // ISTEAMUSER_H

960
sdk/steam/isteamuserstats.h
View file

@ -1,480 +1,480 @@
//====== Copyright � 1996-2009, Valve Corporation, All rights reserved. ======= //====== Copyright � 1996-2009, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to stats, achievements, and leaderboards // Purpose: interface to stats, achievements, and leaderboards
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMUSERSTATS_H #ifndef ISTEAMUSERSTATS_H
#define ISTEAMUSERSTATS_H #define ISTEAMUSERSTATS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
#include "isteamremotestorage.h" #include "isteamremotestorage.h"
// size limit on stat or achievement name (UTF-8 encoded) // size limit on stat or achievement name (UTF-8 encoded)
enum { k_cchStatNameMax = 128 }; enum { k_cchStatNameMax = 128 };
// maximum number of bytes for a leaderboard name (UTF-8 encoded) // maximum number of bytes for a leaderboard name (UTF-8 encoded)
enum { k_cchLeaderboardNameMax = 128 }; enum { k_cchLeaderboardNameMax = 128 };
// maximum number of details int32's storable for a single leaderboard entry // maximum number of details int32's storable for a single leaderboard entry
enum { k_cLeaderboardDetailsMax = 64 }; enum { k_cLeaderboardDetailsMax = 64 };
// handle to a single leaderboard // handle to a single leaderboard
typedef uint64 SteamLeaderboard_t; typedef uint64 SteamLeaderboard_t;
// handle to a set of downloaded entries in a leaderboard // handle to a set of downloaded entries in a leaderboard
typedef uint64 SteamLeaderboardEntries_t; typedef uint64 SteamLeaderboardEntries_t;
// type of data request, when downloading leaderboard entries // type of data request, when downloading leaderboard entries
enum ELeaderboardDataRequest enum ELeaderboardDataRequest
{ {
k_ELeaderboardDataRequestGlobal = 0, k_ELeaderboardDataRequestGlobal = 0,
k_ELeaderboardDataRequestGlobalAroundUser = 1, k_ELeaderboardDataRequestGlobalAroundUser = 1,
k_ELeaderboardDataRequestFriends = 2, k_ELeaderboardDataRequestFriends = 2,
k_ELeaderboardDataRequestUsers = 3 k_ELeaderboardDataRequestUsers = 3
}; };
// the sort order of a leaderboard // the sort order of a leaderboard
enum ELeaderboardSortMethod enum ELeaderboardSortMethod
{ {
k_ELeaderboardSortMethodNone = 0, k_ELeaderboardSortMethodNone = 0,
k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number
k_ELeaderboardSortMethodDescending = 2, // top-score is highest number k_ELeaderboardSortMethodDescending = 2, // top-score is highest number
}; };
// the display type (used by the Steam Community web site) for a leaderboard // the display type (used by the Steam Community web site) for a leaderboard
enum ELeaderboardDisplayType enum ELeaderboardDisplayType
{ {
k_ELeaderboardDisplayTypeNone = 0, k_ELeaderboardDisplayTypeNone = 0,
k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score
k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds
k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds
}; };
enum ELeaderboardUploadScoreMethod enum ELeaderboardUploadScoreMethod
{ {
k_ELeaderboardUploadScoreMethodNone = 0, k_ELeaderboardUploadScoreMethodNone = 0,
k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score
k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified
}; };
// a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry() // a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry()
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
struct LeaderboardEntry_t struct LeaderboardEntry_t
{ {
CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info 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_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_nScore; // score as set in the leaderboard
int32 m_cDetails; // number of int32 details available for this entry int32 m_cDetails; // number of int32 details available for this entry
UGCHandle_t m_hUGC; // handle for UGC attached to the entry UGCHandle_t m_hUGC; // handle for UGC attached to the entry
}; };
#pragma pack( pop ) #pragma pack( pop )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for accessing stats, achievements, and leaderboard information // Purpose: Functions for accessing stats, achievements, and leaderboard information
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamUserStats class ISteamUserStats
{ {
public: public:
// Ask the server to send down this user's data and achievements for this game // Ask the server to send down this user's data and achievements for this game
// On V013: // On V013:
// Note: this call is no longer required as it is managed by the Steam client // Note: this call is no longer required as it is managed by the Steam client
// The game stats and achievements will be synchronized with Steam before // The game stats and achievements will be synchronized with Steam before
// the game process begins. // the game process begins.
// virtual bool RequestCurrentStats() = 0; // virtual bool RequestCurrentStats() = 0;
// Data accessors // Data accessors
STEAM_FLAT_NAME( GetStatInt32 ) STEAM_FLAT_NAME( GetStatInt32 )
virtual bool GetStat( const char *pchName, int32 *pData ) = 0; virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
STEAM_FLAT_NAME( GetStatFloat ) STEAM_FLAT_NAME( GetStatFloat )
virtual bool GetStat( const char *pchName, float *pData ) = 0; virtual bool GetStat( const char *pchName, float *pData ) = 0;
// Set / update data // Set / update data
STEAM_FLAT_NAME( SetStatInt32 ) STEAM_FLAT_NAME( SetStatInt32 )
virtual bool SetStat( const char *pchName, int32 nData ) = 0; virtual bool SetStat( const char *pchName, int32 nData ) = 0;
STEAM_FLAT_NAME( SetStatFloat ) STEAM_FLAT_NAME( SetStatFloat )
virtual bool SetStat( const char *pchName, float fData ) = 0; virtual bool SetStat( const char *pchName, float fData ) = 0;
virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0; virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
// Achievement flag accessors // Achievement flag accessors
virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0; virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0;
virtual bool SetAchievement( const char *pchName ) = 0; virtual bool SetAchievement( const char *pchName ) = 0;
virtual bool ClearAchievement( const char *pchName ) = 0; virtual bool ClearAchievement( const char *pchName ) = 0;
// Get the achievement status, and the time it was unlocked if unlocked. // 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 // 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. // 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; virtual bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Store the current data on the server, will get a callback when set // Store the current data on the server, will get a callback when set
// And one callback for every new achievement // And one callback for every new achievement
// //
// If the callback has a result of k_EResultInvalidParam, one or more stats // If the callback has a result of k_EResultInvalidParam, one or more stats
// uploaded has been rejected, either because they broke constraints // uploaded has been rejected, either because they broke constraints
// or were out of date. In this case the server sends back updated values. // or were out of date. In this case the server sends back updated values.
// The stats should be re-iterated to keep in sync. // The stats should be re-iterated to keep in sync.
virtual bool StoreStats() = 0; virtual bool StoreStats() = 0;
// Achievement / GroupAchievement metadata // Achievement / GroupAchievement metadata
// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set. // 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 // 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 // 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. // specified achievement.
virtual int GetAchievementIcon( const char *pchName ) = 0; virtual int GetAchievementIcon( const char *pchName ) = 0;
// Get general attributes for an achievement. Accepts the following keys: // Get general attributes for an achievement. Accepts the following keys:
// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8) // - "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) // - "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; virtual const char *GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) = 0;
// Achievement progress - triggers an AchievementProgress callback, that is all. // 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. // 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; 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 // Used for iterating achievements. In general games should not need these functions because they should have a
// list of existing achievements compiled into them // list of existing achievements compiled into them
virtual uint32 GetNumAchievements() = 0; virtual uint32 GetNumAchievements() = 0;
// Get achievement name iAchievement in [0,GetNumAchievements) // Get achievement name iAchievement in [0,GetNumAchievements)
virtual const char *GetAchievementName( uint32 iAchievement ) = 0; virtual const char *GetAchievementName( uint32 iAchievement ) = 0;
// Friends stats & achievements // Friends stats & achievements
// downloads stats for the user // downloads stats for the user
// returns a UserStatsReceived_t received when completed // returns a UserStatsReceived_t received when completed
// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail // 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 // these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
STEAM_CALL_RESULT( UserStatsReceived_t ) STEAM_CALL_RESULT( UserStatsReceived_t )
virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0; virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
// requests stat information for a user, usable after a successful call to RequestUserStats() // requests stat information for a user, usable after a successful call to RequestUserStats()
STEAM_FLAT_NAME( GetUserStatInt32 ) STEAM_FLAT_NAME( GetUserStatInt32 )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
STEAM_FLAT_NAME( GetUserStatFloat ) STEAM_FLAT_NAME( GetUserStatFloat )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0; virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
// See notes for GetAchievementAndUnlockTime above // See notes for GetAchievementAndUnlockTime above
virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0; virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Reset stats // Reset stats
virtual bool ResetAllStats( bool bAchievementsToo ) = 0; virtual bool ResetAllStats( bool bAchievementsToo ) = 0;
// Leaderboard functions // Leaderboard functions
// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet // 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 // This call is asynchronous, with the result returned in LeaderboardFindResult_t
STEAM_CALL_RESULT(LeaderboardFindResult_t) STEAM_CALL_RESULT(LeaderboardFindResult_t)
virtual SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) = 0; 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 // as above, but won't create the leaderboard if it's not found
// This call is asynchronous, with the result returned in LeaderboardFindResult_t // This call is asynchronous, with the result returned in LeaderboardFindResult_t
STEAM_CALL_RESULT( LeaderboardFindResult_t ) STEAM_CALL_RESULT( LeaderboardFindResult_t )
virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0; virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0;
// returns the name of a leaderboard // returns the name of a leaderboard
virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the total number of entries in a leaderboard, as of the last request // returns the total number of entries in a leaderboard, as of the last request
virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the sort method of the leaderboard // returns the sort method of the leaderboard
virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the display type of the leaderboard // returns the display type of the leaderboard
virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// Asks the Steam back-end for a set of rows in the leaderboard. // Asks the Steam back-end for a set of rows in the leaderboard.
// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t // This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below) // 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. // 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_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 // 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 // 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 // k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
virtual SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) = 0; 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 // 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 // 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 // a max of 100 users can be downloaded at a time, with only one outstanding call at a time
STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers) STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0; STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0;
// Returns data about a single leaderboard entry // Returns data about a single leaderboard entry
// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries // use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
// e.g. // e.g.
// void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded ) // void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
// { // {
// for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ ) // for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
// { // {
// LeaderboardEntry_t leaderboardEntry; // LeaderboardEntry_t leaderboardEntry;
// int32 details[3]; // we know this is how many we've stored previously // int32 details[3]; // we know this is how many we've stored previously
// GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 ); // GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
// assert( leaderboardEntry.m_cDetails == 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 // 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; 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. // Uploads a user score to the Steam back-end.
// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t // This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
// Details are extra game-defined information regarding how the user got that score // 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 // pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
STEAM_CALL_RESULT( LeaderboardScoreUploaded_t ) STEAM_CALL_RESULT( LeaderboardScoreUploaded_t )
virtual SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) = 0; 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. // 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(). // 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. // This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
STEAM_CALL_RESULT( LeaderboardUGCSet_t ) STEAM_CALL_RESULT( LeaderboardUGCSet_t )
virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0; virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0;
// Retrieves the number of players currently playing your game (online + offline) // Retrieves the number of players currently playing your game (online + offline)
// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t // This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
STEAM_CALL_RESULT( NumberOfCurrentPlayers_t ) STEAM_CALL_RESULT( NumberOfCurrentPlayers_t )
virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0; virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0;
// Requests that Steam fetch data on the percentage of players who have received each achievement // Requests that Steam fetch data on the percentage of players who have received each achievement
// for the game globally. // for the game globally.
// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t. // This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t ) STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t )
virtual SteamAPICall_t RequestGlobalAchievementPercentages() = 0; 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 // 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 // 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). // percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
virtual int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; 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 // 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 // GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
// achievement has been iterated. // achievement has been iterated.
virtual int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; 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. // Returns the percentage of users who have achieved the specified achievement.
virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0; virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0;
// Requests global stats data, which is available for stats marked as "aggregated". // Requests global stats data, which is available for stats marked as "aggregated".
// This call is asynchronous, with the results returned in GlobalStatsReceived_t. // 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 // nHistoryDays specifies how many days of day-by-day history to retrieve in addition
// to the overall totals. The limit is 60. // to the overall totals. The limit is 60.
STEAM_CALL_RESULT( GlobalStatsReceived_t ) STEAM_CALL_RESULT( GlobalStatsReceived_t )
virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0; virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0;
// Gets the lifetime totals for an aggregated stat // Gets the lifetime totals for an aggregated stat
STEAM_FLAT_NAME( GetGlobalStatInt64 ) STEAM_FLAT_NAME( GetGlobalStatInt64 )
virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0; virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
STEAM_FLAT_NAME( GetGlobalStatDouble ) STEAM_FLAT_NAME( GetGlobalStatDouble )
virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0; 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. // 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, // 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 // etc. cubData is the size in bytes of the pubData buffer. Returns the number of
// elements actually set. // elements actually set.
STEAM_FLAT_NAME( GetGlobalStatHistoryInt64 ) STEAM_FLAT_NAME( GetGlobalStatHistoryInt64 )
virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0; virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0;
STEAM_FLAT_NAME( GetGlobalStatHistoryDouble ) STEAM_FLAT_NAME( GetGlobalStatHistoryDouble )
virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) double *pData, uint32 cubData ) = 0; 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. // 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 // 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. // have been made, to show a progress notification to the user.
STEAM_FLAT_NAME( GetAchievementProgressLimitsInt32 ) STEAM_FLAT_NAME( GetAchievementProgressLimitsInt32 )
virtual bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) = 0; virtual bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) = 0;
STEAM_FLAT_NAME( GetAchievementProgressLimitsFloat ) STEAM_FLAT_NAME( GetAchievementProgressLimitsFloat )
virtual bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) = 0; virtual bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) = 0;
}; };
#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION013" #define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION013"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamUserStats *SteamUserStats(); inline ISteamUserStats *SteamUserStats();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUserStats *, SteamUserStats, STEAMUSERSTATS_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUserStats *, SteamUserStats, STEAMUSERSTATS_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when the latests stats and achievements have been received // Purpose: called when the latests stats and achievements have been received
// from the server // from the server
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct UserStatsReceived_t struct UserStatsReceived_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 };
uint64 m_nGameID; // Game these stats are for uint64 m_nGameID; // Game these stats are for
EResult m_eResult; // Success / error fetching the stats EResult m_eResult; // Success / error fetching the stats
CSteamID m_steamIDUser; // The user for whom the stats are retrieved for 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 // Purpose: result of a request to store the user stats for a game
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct UserStatsStored_t struct UserStatsStored_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 };
uint64 m_nGameID; // Game these stats are for uint64 m_nGameID; // Game these stats are for
EResult m_eResult; // success / error EResult m_eResult; // success / error
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: result of a request to store the achievements for a game, or an // Purpose: result of a request to store the achievements for a game, or an
// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress // "indicate progress" call. If both m_nCurProgress and m_nMaxProgress
// are zero, that means the achievement has been fully unlocked. // are zero, that means the achievement has been fully unlocked.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct UserAchievementStored_t struct UserAchievementStored_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 };
uint64 m_nGameID; // Game this is for uint64 m_nGameID; // Game this is for
bool m_bGroupAchievement; // if this is a "group" achievement bool m_bGroupAchievement; // if this is a "group" achievement
char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
uint32 m_nCurProgress; // current progress towards the achievement uint32 m_nCurProgress; // current progress towards the achievement
uint32 m_nMaxProgress; // "out of" this many uint32 m_nMaxProgress; // "out of" this many
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard() // 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 // use CCallResult<> to map this async result to a member function
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct LeaderboardFindResult_t struct LeaderboardFindResult_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 4 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 4 };
SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found
uint8 m_bLeaderboardFound; // 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() // 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 // use CCallResult<> to map this async result to a member function
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct LeaderboardScoresDownloaded_t struct LeaderboardScoresDownloaded_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 5 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 5 };
SteamLeaderboard_t m_hSteamLeaderboard; SteamLeaderboard_t m_hSteamLeaderboard;
SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries() SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries()
int m_cEntryCount; // the number of entries downloaded int m_cEntryCount; // the number of entries downloaded
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore() // 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 // use CCallResult<> to map this async result to a member function
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct LeaderboardScoreUploaded_t struct LeaderboardScoreUploaded_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 6 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 6 };
uint8 m_bSuccess; // 1 if the call was successful uint8 m_bSuccess; // 1 if the call was successful
SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
int32 m_nScore; // the score that was attempted to set 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 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_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 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 struct NumberOfCurrentPlayers_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 7 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 7 };
uint8 m_bSuccess; // 1 if the call was successful uint8 m_bSuccess; // 1 if the call was successful
int32 m_cPlayers; // Number of players currently playing int32 m_cPlayers; // Number of players currently playing
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Callback indicating that a user's stats have been unloaded. // Purpose: Callback indicating that a user's stats have been unloaded.
// Call RequestUserStats again to access stats for this user // Call RequestUserStats again to access stats for this user
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct UserStatsUnloaded_t struct UserStatsUnloaded_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 };
CSteamID m_steamIDUser; // User whose stats have been unloaded CSteamID m_steamIDUser; // User whose stats have been unloaded
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Callback indicating that an achievement icon has been fetched // Purpose: Callback indicating that an achievement icon has been fetched
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct UserAchievementIconFetched_t struct UserAchievementIconFetched_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 9 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 9 };
CGameID m_nGameID; // Game this is for CGameID m_nGameID; // Game this is for
char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
bool m_bAchieved; // Is the icon for the achieved or not achieved version? 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 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 // Purpose: Callback indicating that global achievement percentages are fetched
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GlobalAchievementPercentagesReady_t struct GlobalAchievementPercentagesReady_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 10 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 10 };
uint64 m_nGameID; // Game this is for uint64 m_nGameID; // Game this is for
EResult m_eResult; // Result of the operation EResult m_eResult; // Result of the operation
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC() // Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct LeaderboardUGCSet_t struct LeaderboardUGCSet_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 11 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 11 };
EResult m_eResult; // The result of the operation EResult m_eResult; // The result of the operation
SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: callback indicating global stats have been received. // Purpose: callback indicating global stats have been received.
// Returned as a result of RequestGlobalStats() // Returned as a result of RequestGlobalStats()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GlobalStatsReceived_t struct GlobalStatsReceived_t
{ {
enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 }; enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
uint64 m_nGameID; // Game global stats were requested for uint64 m_nGameID; // Game global stats were requested for
EResult m_eResult; // The result of the request EResult m_eResult; // The result of the request
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMUSER_H #endif // ISTEAMUSER_H

460
sdk/steam/isteamuserstats012.h
View file

@ -1,230 +1,230 @@
#ifndef ISTEAMUSERSTATS012_H #ifndef ISTEAMUSERSTATS012_H
#define ISTEAMUSERSTATS012_H #define ISTEAMUSERSTATS012_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Functions for accessing stats, achievements, and leaderboard information // Purpose: Functions for accessing stats, achievements, and leaderboard information
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamUserStats012 class ISteamUserStats012
{ {
public: public:
// Ask the server to send down this user's data and achievements for this game // Ask the server to send down this user's data and achievements for this game
STEAM_CALL_BACK( UserStatsReceived_t ) STEAM_CALL_BACK( UserStatsReceived_t )
virtual bool RequestCurrentStats() = 0; virtual bool RequestCurrentStats() = 0;
// Data accessors // Data accessors
STEAM_FLAT_NAME( GetStatInt32 ) STEAM_FLAT_NAME( GetStatInt32 )
virtual bool GetStat( const char *pchName, int32 *pData ) = 0; virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
STEAM_FLAT_NAME( GetStatFloat ) STEAM_FLAT_NAME( GetStatFloat )
virtual bool GetStat( const char *pchName, float *pData ) = 0; virtual bool GetStat( const char *pchName, float *pData ) = 0;
// Set / update data // Set / update data
STEAM_FLAT_NAME( SetStatInt32 ) STEAM_FLAT_NAME( SetStatInt32 )
virtual bool SetStat( const char *pchName, int32 nData ) = 0; virtual bool SetStat( const char *pchName, int32 nData ) = 0;
STEAM_FLAT_NAME( SetStatFloat ) STEAM_FLAT_NAME( SetStatFloat )
virtual bool SetStat( const char *pchName, float fData ) = 0; virtual bool SetStat( const char *pchName, float fData ) = 0;
virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0; virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
// Achievement flag accessors // Achievement flag accessors
virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0; virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0;
virtual bool SetAchievement( const char *pchName ) = 0; virtual bool SetAchievement( const char *pchName ) = 0;
virtual bool ClearAchievement( const char *pchName ) = 0; virtual bool ClearAchievement( const char *pchName ) = 0;
// Get the achievement status, and the time it was unlocked if unlocked. // 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 // 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. // 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; virtual bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Store the current data on the server, will get a callback when set // Store the current data on the server, will get a callback when set
// And one callback for every new achievement // And one callback for every new achievement
// //
// If the callback has a result of k_EResultInvalidParam, one or more stats // If the callback has a result of k_EResultInvalidParam, one or more stats
// uploaded has been rejected, either because they broke constraints // uploaded has been rejected, either because they broke constraints
// or were out of date. In this case the server sends back updated values. // or were out of date. In this case the server sends back updated values.
// The stats should be re-iterated to keep in sync. // The stats should be re-iterated to keep in sync.
virtual bool StoreStats() = 0; virtual bool StoreStats() = 0;
// Achievement / GroupAchievement metadata // Achievement / GroupAchievement metadata
// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set. // 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 // 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 // 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. // specified achievement.
virtual int GetAchievementIcon( const char *pchName ) = 0; virtual int GetAchievementIcon( const char *pchName ) = 0;
// Get general attributes for an achievement. Accepts the following keys: // Get general attributes for an achievement. Accepts the following keys:
// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8) // - "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) // - "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; virtual const char *GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) = 0;
// Achievement progress - triggers an AchievementProgress callback, that is all. // 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. // 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; 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 // Used for iterating achievements. In general games should not need these functions because they should have a
// list of existing achievements compiled into them // list of existing achievements compiled into them
virtual uint32 GetNumAchievements() = 0; virtual uint32 GetNumAchievements() = 0;
// Get achievement name iAchievement in [0,GetNumAchievements) // Get achievement name iAchievement in [0,GetNumAchievements)
virtual const char *GetAchievementName( uint32 iAchievement ) = 0; virtual const char *GetAchievementName( uint32 iAchievement ) = 0;
// Friends stats & achievements // Friends stats & achievements
// downloads stats for the user // downloads stats for the user
// returns a UserStatsReceived_t received when completed // returns a UserStatsReceived_t received when completed
// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail // 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 // these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
STEAM_CALL_RESULT( UserStatsReceived_t ) STEAM_CALL_RESULT( UserStatsReceived_t )
virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0; virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
// requests stat information for a user, usable after a successful call to RequestUserStats() // requests stat information for a user, usable after a successful call to RequestUserStats()
STEAM_FLAT_NAME( GetUserStatInt32 ) STEAM_FLAT_NAME( GetUserStatInt32 )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
STEAM_FLAT_NAME( GetUserStatFloat ) STEAM_FLAT_NAME( GetUserStatFloat )
virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0; virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0; virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
// See notes for GetAchievementAndUnlockTime above // See notes for GetAchievementAndUnlockTime above
virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0; virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
// Reset stats // Reset stats
virtual bool ResetAllStats( bool bAchievementsToo ) = 0; virtual bool ResetAllStats( bool bAchievementsToo ) = 0;
// Leaderboard functions // Leaderboard functions
// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet // 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 // This call is asynchronous, with the result returned in LeaderboardFindResult_t
STEAM_CALL_RESULT(LeaderboardFindResult_t) STEAM_CALL_RESULT(LeaderboardFindResult_t)
virtual SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) = 0; 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 // as above, but won't create the leaderboard if it's not found
// This call is asynchronous, with the result returned in LeaderboardFindResult_t // This call is asynchronous, with the result returned in LeaderboardFindResult_t
STEAM_CALL_RESULT( LeaderboardFindResult_t ) STEAM_CALL_RESULT( LeaderboardFindResult_t )
virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0; virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0;
// returns the name of a leaderboard // returns the name of a leaderboard
virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the total number of entries in a leaderboard, as of the last request // returns the total number of entries in a leaderboard, as of the last request
virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the sort method of the leaderboard // returns the sort method of the leaderboard
virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// returns the display type of the leaderboard // returns the display type of the leaderboard
virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0; virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0;
// Asks the Steam back-end for a set of rows in the leaderboard. // Asks the Steam back-end for a set of rows in the leaderboard.
// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t // This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below) // 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. // 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_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 // 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 // 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 // k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
virtual SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) = 0; 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 // 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 // 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 // a max of 100 users can be downloaded at a time, with only one outstanding call at a time
STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers) STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0; STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0;
// Returns data about a single leaderboard entry // Returns data about a single leaderboard entry
// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries // use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
// e.g. // e.g.
// void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded ) // void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
// { // {
// for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ ) // for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
// { // {
// LeaderboardEntry_t leaderboardEntry; // LeaderboardEntry_t leaderboardEntry;
// int32 details[3]; // we know this is how many we've stored previously // int32 details[3]; // we know this is how many we've stored previously
// GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 ); // GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
// assert( leaderboardEntry.m_cDetails == 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 // 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; 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. // Uploads a user score to the Steam back-end.
// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t // This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
// Details are extra game-defined information regarding how the user got that score // 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 // pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
STEAM_CALL_RESULT( LeaderboardScoreUploaded_t ) STEAM_CALL_RESULT( LeaderboardScoreUploaded_t )
virtual SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) = 0; 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. // 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(). // 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. // This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
STEAM_CALL_RESULT( LeaderboardUGCSet_t ) STEAM_CALL_RESULT( LeaderboardUGCSet_t )
virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0; virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0;
// Retrieves the number of players currently playing your game (online + offline) // Retrieves the number of players currently playing your game (online + offline)
// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t // This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
STEAM_CALL_RESULT( NumberOfCurrentPlayers_t ) STEAM_CALL_RESULT( NumberOfCurrentPlayers_t )
virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0; virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0;
// Requests that Steam fetch data on the percentage of players who have received each achievement // Requests that Steam fetch data on the percentage of players who have received each achievement
// for the game globally. // for the game globally.
// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t. // This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t ) STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t )
virtual SteamAPICall_t RequestGlobalAchievementPercentages() = 0; 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 // 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 // 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). // percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
virtual int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; 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 // 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 // GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
// achievement has been iterated. // achievement has been iterated.
virtual int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0; 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. // Returns the percentage of users who have achieved the specified achievement.
virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0; virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0;
// Requests global stats data, which is available for stats marked as "aggregated". // Requests global stats data, which is available for stats marked as "aggregated".
// This call is asynchronous, with the results returned in GlobalStatsReceived_t. // 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 // nHistoryDays specifies how many days of day-by-day history to retrieve in addition
// to the overall totals. The limit is 60. // to the overall totals. The limit is 60.
STEAM_CALL_RESULT( GlobalStatsReceived_t ) STEAM_CALL_RESULT( GlobalStatsReceived_t )
virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0; virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0;
// Gets the lifetime totals for an aggregated stat // Gets the lifetime totals for an aggregated stat
STEAM_FLAT_NAME( GetGlobalStatInt64 ) STEAM_FLAT_NAME( GetGlobalStatInt64 )
virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0; virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
STEAM_FLAT_NAME( GetGlobalStatDouble ) STEAM_FLAT_NAME( GetGlobalStatDouble )
virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0; 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. // 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, // 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 // etc. cubData is the size in bytes of the pubData buffer. Returns the number of
// elements actually set. // elements actually set.
STEAM_FLAT_NAME( GetGlobalStatHistoryInt64 ) STEAM_FLAT_NAME( GetGlobalStatHistoryInt64 )
virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0; virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) = 0;
STEAM_FLAT_NAME( GetGlobalStatHistoryDouble ) STEAM_FLAT_NAME( GetGlobalStatHistoryDouble )
virtual int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) double *pData, uint32 cubData ) = 0; 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. // 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 // 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. // have been made, to show a progress notification to the user.
STEAM_FLAT_NAME( GetAchievementProgressLimitsInt32 ) STEAM_FLAT_NAME( GetAchievementProgressLimitsInt32 )
virtual bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) = 0; virtual bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) = 0;
STEAM_FLAT_NAME( GetAchievementProgressLimitsFloat ) STEAM_FLAT_NAME( GetAchievementProgressLimitsFloat )
virtual bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) = 0; virtual bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) = 0;
}; };
#endif // ISTEAMUSERSTATS012_H #endif // ISTEAMUSERSTATS012_H

708
sdk/steam/isteamutils.h
View file

@ -1,354 +1,354 @@
//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to utility functions in Steam // Purpose: interface to utility functions in Steam
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMUTILS_H #ifndef ISTEAMUTILS_H
#define ISTEAMUTILS_H #define ISTEAMUTILS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// Steam API call failure results // Steam API call failure results
enum ESteamAPICallFailure enum ESteamAPICallFailure
{ {
k_ESteamAPICallFailureNone = -1, // no failure k_ESteamAPICallFailureNone = -1, // no failure
k_ESteamAPICallFailureSteamGone = 0, // the local Steam process has gone away 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 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 // 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 // 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_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 k_ESteamAPICallFailureMismatchedCallback = 3,// GetAPICallResult() was called with the wrong callback type for this API call
}; };
// Input modes for the Big Picture gamepad text entry // Input modes for the Big Picture gamepad text entry
enum EGamepadTextInputMode enum EGamepadTextInputMode
{ {
k_EGamepadTextInputModeNormal = 0, k_EGamepadTextInputModeNormal = 0,
k_EGamepadTextInputModePassword = 1 k_EGamepadTextInputModePassword = 1
}; };
// Controls number of allowed lines for the Big Picture gamepad text entry // Controls number of allowed lines for the Big Picture gamepad text entry
enum EGamepadTextInputLineMode enum EGamepadTextInputLineMode
{ {
k_EGamepadTextInputLineModeSingleLine = 0, k_EGamepadTextInputLineModeSingleLine = 0,
k_EGamepadTextInputLineModeMultipleLines = 1 k_EGamepadTextInputLineModeMultipleLines = 1
}; };
enum EFloatingGamepadTextInputMode enum EFloatingGamepadTextInputMode
{ {
k_EFloatingGamepadTextInputModeModeSingleLine = 0, // Enter dismisses the keyboard k_EFloatingGamepadTextInputModeModeSingleLine = 0, // Enter dismisses the keyboard
k_EFloatingGamepadTextInputModeModeMultipleLines = 1, // User needs to explictly close the keyboard k_EFloatingGamepadTextInputModeModeMultipleLines = 1, // User needs to explictly close the keyboard
k_EFloatingGamepadTextInputModeModeEmail = 2, // Keyboard layout is email, enter dismisses the keyboard k_EFloatingGamepadTextInputModeModeEmail = 2, // Keyboard layout is email, enter dismisses the keyboard
k_EFloatingGamepadTextInputModeModeNumeric = 3, // Keyboard layout is numeric, enter dismisses the keyboard k_EFloatingGamepadTextInputModeModeNumeric = 3, // Keyboard layout is numeric, enter dismisses the keyboard
}; };
// The context where text filtering is being done // The context where text filtering is being done
enum ETextFilteringContext enum ETextFilteringContext
{ {
k_ETextFilteringContextUnknown = 0, // Unknown context k_ETextFilteringContextUnknown = 0, // Unknown context
k_ETextFilteringContextGameContent = 1, // Game content, only legally required filtering is performed k_ETextFilteringContextGameContent = 1, // Game content, only legally required filtering is performed
k_ETextFilteringContextChat = 2, // Chat from another player k_ETextFilteringContextChat = 2, // Chat from another player
k_ETextFilteringContextName = 3, // Character or item name k_ETextFilteringContextName = 3, // Character or item name
}; };
// function prototype for warning message hook // function prototype for warning message hook
#if defined( POSIX ) #if defined( POSIX )
#define __cdecl #define __cdecl
#endif #endif
extern "C" typedef void (__cdecl *SteamAPIWarningMessageHook_t)(int, const char *); extern "C" typedef void (__cdecl *SteamAPIWarningMessageHook_t)(int, const char *);
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: interface to user independent utility functions // Purpose: interface to user independent utility functions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamUtils class ISteamUtils
{ {
public: public:
// return the number of seconds since the user // return the number of seconds since the user
virtual uint32 GetSecondsSinceAppActive() = 0; virtual uint32 GetSecondsSinceAppActive() = 0;
virtual uint32 GetSecondsSinceComputerActive() = 0; virtual uint32 GetSecondsSinceComputerActive() = 0;
// the universe this client is connecting to // the universe this client is connecting to
virtual EUniverse GetConnectedUniverse() = 0; virtual EUniverse GetConnectedUniverse() = 0;
// Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time) // Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time)
virtual uint32 GetServerRealTime() = 0; 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) // 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". // e.g "US" or "UK".
virtual const char *GetIPCountry() = 0; virtual const char *GetIPCountry() = 0;
// returns true if the image exists, and valid sizes were filled out // returns true if the image exists, and valid sizes were filled out
virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0; virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0;
// returns true if the image exists, and the buffer was successfully filled out // returns true if the image exists, and the buffer was successfully filled out
// results are returned in RGBA format // results are returned in RGBA format
// the destination buffer size should be 4 * height * width * sizeof(char) // the destination buffer size should be 4 * height * width * sizeof(char)
virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0; virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0;
// Deprecated. Do not call this. // Deprecated. Do not call this.
STEAM_PRIVATE_API( virtual bool GetCSERIPPort( uint32 *unIP, uint16 *usPort ) = 0; ) 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 // return the amount of battery power left in the current system in % [0..100], 255 for being on AC power
virtual uint8 GetCurrentBatteryPower() = 0; virtual uint8 GetCurrentBatteryPower() = 0;
// returns the appID of the current process // returns the appID of the current process
virtual uint32 GetAppID() = 0; virtual uint32 GetAppID() = 0;
// Sets the position where the overlay instance for the currently calling game should show notifications. // 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. // 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; virtual void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition ) = 0;
// API asynchronous call results // API asynchronous call results
// can be used directly, but more commonly used via the callback dispatch API (see steam_api.h) // 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 bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed ) = 0;
virtual ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) = 0; virtual ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) = 0;
virtual bool GetAPICallResult( SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ) = 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. // Deprecated. Applications should use SteamAPI_RunCallbacks() instead. Game servers do not need to call this function.
STEAM_PRIVATE_API( virtual void RunFrame() = 0; ) STEAM_PRIVATE_API( virtual void RunFrame() = 0; )
// returns the number of IPC calls made since the last time this function was called // 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 // 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 // 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. // control how often you do them.
virtual uint32 GetIPCCallCount() = 0; virtual uint32 GetIPCCallCount() = 0;
// API warning handling // API warning handling
// 'int' is the severity; 0 for msg, 1 for warning // 'int' is the severity; 0 for msg, 1 for warning
// 'const char *' is the text of the message // 'const char *' is the text of the message
// callbacks will occur directly after the API function is called that generated the warning or message // callbacks will occur directly after the API function is called that generated the warning or message
virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0; 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 // 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. // start & hook the game process, so this function will initially return false while the overlay is loading.
virtual bool IsOverlayEnabled() = 0; virtual bool IsOverlayEnabled() = 0;
// Normally this call is unneeded if your game has a constantly running frame loop that calls the // 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. // 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 // 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 // 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 // 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 // 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 // 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. // refresh the screen with Present or SwapBuffers to allow the overlay to do it's work.
virtual bool BOverlayNeedsPresent() = 0; virtual bool BOverlayNeedsPresent() = 0;
// Asynchronous call to check if an executable file has been signed using the public key set on the signing tab // 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. // of the partner site, for example to refuse to load modified executable files.
// The result is returned in CheckFileSignature_t. // 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_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_ECheckFileSignatureNoSignaturesFoundForThisFile - This file is not listed on the signing tab for the partner site.
// k_ECheckFileSignatureFileNotFound - The file does not exist on disk. // 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_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. // k_ECheckFileSignatureValidSignature - The file is signed and the signature is valid.
STEAM_CALL_RESULT( CheckFileSignature_t ) STEAM_CALL_RESULT( CheckFileSignature_t )
virtual SteamAPICall_t CheckFileSignature( const char *szFileName ) = 0; 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 // 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; virtual bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText ) = 0;
// Returns previously entered text & length // Returns previously entered text & length
virtual uint32 GetEnteredGamepadTextLength() = 0; virtual uint32 GetEnteredGamepadTextLength() = 0;
virtual bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText ) = 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 // 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; virtual const char *GetSteamUILanguage() = 0;
// returns true if Steam itself is running in VR mode // returns true if Steam itself is running in VR mode
virtual bool IsSteamRunningInVR() = 0; virtual bool IsSteamRunningInVR() = 0;
// Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition. // Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition.
virtual void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) = 0; virtual void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) = 0;
// returns true if Steam & the Steam Overlay are running in Big Picture mode // 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, // 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 // a game can be added as a non-steam game to the developers library to test this feature
virtual bool IsSteamInBigPictureMode() = 0; virtual bool IsSteamInBigPictureMode() = 0;
// ask SteamUI to create and render its OpenVR dashboard // ask SteamUI to create and render its OpenVR dashboard
virtual void StartVRDashboard() = 0; virtual void StartVRDashboard() = 0;
// Returns true if the HMD content will be streamed via Steam Remote Play // Returns true if the HMD content will be streamed via Steam Remote Play
virtual bool IsVRHeadsetStreamingEnabled() = 0; virtual bool IsVRHeadsetStreamingEnabled() = 0;
// Set whether the HMD content will be streamed via Steam Remote Play // 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 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. // 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. // 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) // (this is useful for games that have asymmetric multiplayer gameplay)
virtual void SetVRHeadsetStreamingEnabled( bool bEnabled ) = 0; virtual void SetVRHeadsetStreamingEnabled( bool bEnabled ) = 0;
// Returns whether this steam client is a Steam China specific client, vs the global client. // Returns whether this steam client is a Steam China specific client, vs the global client.
virtual bool IsSteamChinaLauncher() = 0; virtual bool IsSteamChinaLauncher() = 0;
// Initializes text filtering, loading dictionaries for the language the game is running in. // 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 // 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. // 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: // Users can customize the text filter behavior in their Steam Account preferences:
// https://store.steampowered.com/account/preferences#CommunityContentPreferences // https://store.steampowered.com/account/preferences#CommunityContentPreferences
virtual bool InitFilterText( uint32 unFilterOptions = 0 ) = 0; 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 // 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 // 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) // 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 // 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 // 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 // nByteSizeOutFilteredText is the size (in bytes) of pchOutFilteredText, should be at least strlen(pchInputText)+1
// Returns the number of characters (not bytes) filtered // Returns the number of characters (not bytes) filtered
virtual int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const char *pchInputMessage, char *pchOutFilteredText, uint32 nByteSizeOutFilteredText ) = 0; 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. // 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. // This does NOT tell you if the Steam client is currently connected to Steam via ipv6.
virtual ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol ) = 0; virtual ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol ) = 0;
// returns true if currently running on the Steam Deck device // returns true if currently running on the Steam Deck device
virtual bool IsSteamRunningOnSteamDeck() = 0; virtual bool IsSteamRunningOnSteamDeck() = 0;
// Opens a floating keyboard over the game content and sends OS keyboard keys directly to the game. // 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 // 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; 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 // 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; virtual void SetGameLauncherMode( bool bLauncherMode ) = 0;
// Dismisses the floating keyboard. // Dismisses the floating keyboard.
virtual bool DismissFloatingGamepadTextInput() = 0; virtual bool DismissFloatingGamepadTextInput() = 0;
// Dismisses the full-screen text input dialog. // Dismisses the full-screen text input dialog.
virtual bool DismissGamepadTextInput() = 0; virtual bool DismissGamepadTextInput() = 0;
}; };
#define STEAMUTILS_INTERFACE_VERSION "SteamUtils010" #define STEAMUTILS_INTERFACE_VERSION "SteamUtils010"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamUtils *SteamUtils(); inline ISteamUtils *SteamUtils();
STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamUtils, SteamInternal_FindOrCreateUserInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "user", STEAMUTILS_INTERFACE_VERSION ); STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamUtils, SteamInternal_FindOrCreateUserInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "user", STEAMUTILS_INTERFACE_VERSION );
// Global accessor for the gameserver client // Global accessor for the gameserver client
inline ISteamUtils *SteamGameServerUtils(); inline ISteamUtils *SteamGameServerUtils();
STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamGameServerUtils, SteamInternal_FindOrCreateGameServerInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "gameserver", STEAMUTILS_INTERFACE_VERSION ); STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamUtils *, SteamGameServerUtils, SteamInternal_FindOrCreateGameServerInterface( 0, STEAMUTILS_INTERFACE_VERSION ), "gameserver", STEAMUTILS_INTERFACE_VERSION );
#endif #endif
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: The country of the user changed // Purpose: The country of the user changed
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct IPCountry_t struct IPCountry_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 1 }; 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 // 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 struct LowBatteryPower_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 2 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 2 };
uint8 m_nMinutesBatteryLeft; uint8 m_nMinutesBatteryLeft;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: called when a SteamAsyncCall_t has completed (or failed) // Purpose: called when a SteamAsyncCall_t has completed (or failed)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamAPICallCompleted_t struct SteamAPICallCompleted_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 3 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 3 };
SteamAPICall_t m_hAsyncCall; SteamAPICall_t m_hAsyncCall;
int m_iCallback; int m_iCallback;
uint32 m_cubParam; uint32 m_cubParam;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// called when Steam wants to shutdown // called when Steam wants to shutdown
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct SteamShutdown_t struct SteamShutdown_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 4 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 4 };
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// results for CheckFileSignature // results for CheckFileSignature
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum ECheckFileSignature enum ECheckFileSignature
{ {
k_ECheckFileSignatureInvalidSignature = 0, k_ECheckFileSignatureInvalidSignature = 0,
k_ECheckFileSignatureValidSignature = 1, k_ECheckFileSignatureValidSignature = 1,
k_ECheckFileSignatureFileNotFound = 2, k_ECheckFileSignatureFileNotFound = 2,
k_ECheckFileSignatureNoSignaturesFoundForThisApp = 3, k_ECheckFileSignatureNoSignaturesFoundForThisApp = 3,
k_ECheckFileSignatureNoSignaturesFoundForThisFile = 4, k_ECheckFileSignatureNoSignaturesFoundForThisFile = 4,
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// callback for CheckFileSignature // callback for CheckFileSignature
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct CheckFileSignature_t struct CheckFileSignature_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 5 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 5 };
ECheckFileSignature m_eCheckFileSignature; ECheckFileSignature m_eCheckFileSignature;
}; };
// k_iSteamUtilsCallbacks + 13 is taken // k_iSteamUtilsCallbacks + 13 is taken
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Full Screen gamepad text input has been closed // Full Screen gamepad text input has been closed
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct GamepadTextInputDismissed_t struct GamepadTextInputDismissed_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 14 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 14 };
bool m_bSubmitted; // true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input bool m_bSubmitted; // true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input
uint32 m_unSubmittedText; uint32 m_unSubmittedText;
AppId_t m_unAppID; AppId_t m_unAppID;
}; };
// k_iSteamUtilsCallbacks + 15 through 35 are taken // k_iSteamUtilsCallbacks + 15 through 35 are taken
STEAM_CALLBACK_BEGIN( AppResumingFromSuspend_t, k_iSteamUtilsCallbacks + 36 ) STEAM_CALLBACK_BEGIN( AppResumingFromSuspend_t, k_iSteamUtilsCallbacks + 36 )
STEAM_CALLBACK_END(0) STEAM_CALLBACK_END(0)
// k_iSteamUtilsCallbacks + 37 is taken // k_iSteamUtilsCallbacks + 37 is taken
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// The floating on-screen keyboard has been closed // The floating on-screen keyboard has been closed
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct FloatingGamepadTextInputDismissed_t struct FloatingGamepadTextInputDismissed_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 38 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 38 };
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// The text filtering dictionary has changed // The text filtering dictionary has changed
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct FilterTextDictionaryChanged_t struct FilterTextDictionaryChanged_t
{ {
enum { k_iCallback = k_iSteamUtilsCallbacks + 39 }; enum { k_iCallback = k_iSteamUtilsCallbacks + 39 };
int m_eLanguage; // One of ELanguage, or k_LegallyRequiredFiltering int m_eLanguage; // One of ELanguage, or k_LegallyRequiredFiltering
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMUTILS_H #endif // ISTEAMUTILS_H

68
sdk/steam/isteamutils001.h
View file

@ -1,34 +1,34 @@
#ifndef ISTEAMUTILS001_H #ifndef ISTEAMUTILS001_H
#define ISTEAMUTILS001_H #define ISTEAMUTILS001_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
class ISteamUtils001 class ISteamUtils001
{ {
public: public:
// return the number of seconds since the user // return the number of seconds since the user
virtual uint32 GetSecondsSinceAppActive() = 0; virtual uint32 GetSecondsSinceAppActive() = 0;
virtual uint32 GetSecondsSinceComputerActive() = 0; virtual uint32 GetSecondsSinceComputerActive() = 0;
// the universe this client is connecting to // the universe this client is connecting to
virtual EUniverse GetConnectedUniverse() = 0; virtual EUniverse GetConnectedUniverse() = 0;
// Steam server time - in PST, number of seconds since January 1, 1970 (i.e unix time) // Steam server time - in PST, number of seconds since January 1, 1970 (i.e unix time)
virtual uint32 GetServerRealTime() = 0; 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) // 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". // e.g "US" or "UK".
virtual const char *GetIPCountry() = 0; virtual const char *GetIPCountry() = 0;
// returns true if the image exists, and valid sizes were filled out // returns true if the image exists, and valid sizes were filled out
virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0; virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0;
// returns true if the image exists, and the buffer was successfully filled out // returns true if the image exists, and the buffer was successfully filled out
// results are returned in RGBA format // results are returned in RGBA format
// the destination buffer size should be 4 * height * width * sizeof(char) // the destination buffer size should be 4 * height * width * sizeof(char)
virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0; virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0;
}; };
#endif // ISTEAMUTILS001_H #endif // ISTEAMUTILS001_H

150
sdk/steam/isteamvideo.h
View file

@ -1,75 +1,75 @@
//====== Copyright © 1996-2014 Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2014 Valve Corporation, All rights reserved. =======
// //
// Purpose: interface to Steam Video // Purpose: interface to Steam Video
// //
//============================================================================= //=============================================================================
#ifndef ISTEAMVIDEO_H #ifndef ISTEAMVIDEO_H
#define ISTEAMVIDEO_H #define ISTEAMVIDEO_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api_common.h" #include "steam_api_common.h"
// callbacks // callbacks
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Steam Video API // Purpose: Steam Video API
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class ISteamVideo class ISteamVideo
{ {
public: public:
// Get a URL suitable for streaming the given Video app ID's video // Get a URL suitable for streaming the given Video app ID's video
virtual void GetVideoURL( AppId_t unVideoAppID ) = 0; virtual void GetVideoURL( AppId_t unVideoAppID ) = 0;
// returns true if user is uploading a live broadcast // returns true if user is uploading a live broadcast
virtual bool IsBroadcasting( int *pnNumViewers ) = 0; virtual bool IsBroadcasting( int *pnNumViewers ) = 0;
// Get the OPF Details for 360 Video Playback // Get the OPF Details for 360 Video Playback
STEAM_CALL_BACK( GetOPFSettingsResult_t ) STEAM_CALL_BACK( GetOPFSettingsResult_t )
virtual void GetOPFSettings( AppId_t unVideoAppID ) = 0; virtual void GetOPFSettings( AppId_t unVideoAppID ) = 0;
virtual bool GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize ) = 0; virtual bool GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize ) = 0;
}; };
#define STEAMVIDEO_INTERFACE_VERSION "STEAMVIDEO_INTERFACE_V007" #define STEAMVIDEO_INTERFACE_VERSION "STEAMVIDEO_INTERFACE_V007"
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
// Global interface accessor // Global interface accessor
inline ISteamVideo *SteamVideo(); inline ISteamVideo *SteamVideo();
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamVideo *, SteamVideo, STEAMVIDEO_INTERFACE_VERSION ); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamVideo *, SteamVideo, STEAMVIDEO_INTERFACE_VERSION );
#endif #endif
STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iSteamVideoCallbacks + 4 ) STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iSteamVideoCallbacks + 4 )
STEAM_CALLBACK_MEMBER( 0, bool, m_bIsRTMP ) STEAM_CALLBACK_MEMBER( 0, bool, m_bIsRTMP )
STEAM_CALLBACK_END( 1 ) STEAM_CALLBACK_END( 1 )
STEAM_CALLBACK_BEGIN( BroadcastUploadStop_t, k_iClientVideoCallbacks + 5 ) STEAM_CALLBACK_BEGIN( BroadcastUploadStop_t, k_iClientVideoCallbacks + 5 )
STEAM_CALLBACK_MEMBER( 0, EBroadcastUploadResult, m_eResult ) STEAM_CALLBACK_MEMBER( 0, EBroadcastUploadResult, m_eResult )
STEAM_CALLBACK_END(1) STEAM_CALLBACK_END(1)
STEAM_CALLBACK_BEGIN( GetVideoURLResult_t, k_iSteamVideoCallbacks + 11 ) STEAM_CALLBACK_BEGIN( GetVideoURLResult_t, k_iSteamVideoCallbacks + 11 )
STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult ) STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult )
STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID ) STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID )
STEAM_CALLBACK_MEMBER( 2, char, m_rgchURL[256] ) STEAM_CALLBACK_MEMBER( 2, char, m_rgchURL[256] )
STEAM_CALLBACK_END(3) STEAM_CALLBACK_END(3)
STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iSteamVideoCallbacks + 24 ) STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iSteamVideoCallbacks + 24 )
STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult ) STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult )
STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID ) STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID )
STEAM_CALLBACK_END(2) STEAM_CALLBACK_END(2)
#pragma pack( pop ) #pragma pack( pop )
#endif // ISTEAMVIDEO_H #endif // ISTEAMVIDEO_H

34
sdk/steam/isteamvideo001.h
View file

@ -1,18 +1,18 @@
#ifndef ISTEAMVIDEO001_H #ifndef ISTEAMVIDEO001_H
#define ISTEAMVIDEO001_H #define ISTEAMVIDEO001_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
class ISteamVideo001 class ISteamVideo001
{ {
public: public:
// Get a URL suitable for streaming the given Video app ID's video // Get a URL suitable for streaming the given Video app ID's video
virtual void GetVideoURL( AppId_t unVideoAppID ) = 0; virtual void GetVideoURL( AppId_t unVideoAppID ) = 0;
// returns true if user is uploading a live broadcast // returns true if user is uploading a live broadcast
virtual bool IsBroadcasting( int *pnNumViewers ) = 0; virtual bool IsBroadcasting( int *pnNumViewers ) = 0;
}; };
#endif // ISTEAMVIDEO001_H #endif // ISTEAMVIDEO001_H

490
sdk/steam/matchmakingtypes.h
View file

@ -1,245 +1,245 @@
//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ //========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
// //
// Purpose: // Purpose:
// //
// $NoKeywords: $ // $NoKeywords: $
//============================================================================= //=============================================================================
#ifndef MATCHMAKINGTYPES_H #ifndef MATCHMAKINGTYPES_H
#define MATCHMAKINGTYPES_H #define MATCHMAKINGTYPES_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
// //
// Max size (in bytes of UTF-8 data, not in characters) of server fields, including null terminator. // 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. // WARNING: These cannot be changed easily, without breaking clients using old interfaces.
// //
const int k_cbMaxGameServerGameDir = 32; const int k_cbMaxGameServerGameDir = 32;
const int k_cbMaxGameServerMapName = 32; const int k_cbMaxGameServerMapName = 32;
const int k_cbMaxGameServerGameDescription = 64; const int k_cbMaxGameServerGameDescription = 64;
const int k_cbMaxGameServerName = 64; const int k_cbMaxGameServerName = 64;
const int k_cbMaxGameServerTags = 128; const int k_cbMaxGameServerTags = 128;
const int k_cbMaxGameServerGameData = 2048; const int k_cbMaxGameServerGameData = 2048;
/// Store key/value pair used in matchmaking queries. /// Store key/value pair used in matchmaking queries.
/// ///
/// Actually, the name Key/Value is a bit misleading. The "key" is better /// 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 /// understood as "filter operation code" and the "value" is the operand to this
/// filter operation. The meaning of the operand depends upon the filter. /// filter operation. The meaning of the operand depends upon the filter.
struct MatchMakingKeyValuePair_t struct MatchMakingKeyValuePair_t
{ {
MatchMakingKeyValuePair_t() { m_szKey[0] = m_szValue[0] = 0; } MatchMakingKeyValuePair_t() { m_szKey[0] = m_szValue[0] = 0; }
MatchMakingKeyValuePair_t( const char *pchKey, const char *pchValue ) 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! 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'; m_szKey[ sizeof( m_szKey ) - 1 ] = '\0';
strncpy( m_szValue, pchValue, sizeof(m_szValue) ); strncpy( m_szValue, pchValue, sizeof(m_szValue) );
m_szValue[ sizeof( m_szValue ) - 1 ] = '\0'; m_szValue[ sizeof( m_szValue ) - 1 ] = '\0';
} }
char m_szKey[ 256 ]; char m_szKey[ 256 ];
char m_szValue[ 256 ]; char m_szValue[ 256 ];
}; };
enum EMatchMakingServerResponse enum EMatchMakingServerResponse
{ {
eServerResponded = 0, eServerResponded = 0,
eServerFailedToRespond, eServerFailedToRespond,
eNoServersListedOnMasterServer // for the Internet query type, returned in response callback if no servers of this type match 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, // 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. // namely: its IP, its connection port, and its query port.
class servernetadr_t class servernetadr_t
{ {
public: public:
servernetadr_t() : m_usConnectionPort( 0 ), m_usQueryPort( 0 ), m_unIP( 0 ) {} servernetadr_t() : m_usConnectionPort( 0 ), m_usQueryPort( 0 ), m_unIP( 0 ) {}
void Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort ); void Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort );
#ifdef NETADR_H #ifdef NETADR_H
netadr_t GetIPAndQueryPort(); netadr_t GetIPAndQueryPort();
#endif #endif
// Access the query port. // Access the query port.
uint16 GetQueryPort() const; uint16 GetQueryPort() const;
void SetQueryPort( uint16 usPort ); void SetQueryPort( uint16 usPort );
// Access the connection port. // Access the connection port.
uint16 GetConnectionPort() const; uint16 GetConnectionPort() const;
void SetConnectionPort( uint16 usPort ); void SetConnectionPort( uint16 usPort );
// Access the IP // Access the IP
uint32 GetIP() const; uint32 GetIP() const;
void SetIP( uint32 unIP ); void SetIP( uint32 unIP );
// This gets the 'a.b.c.d:port' string with the connection port (instead of the query port). // This gets the 'a.b.c.d:port' string with the connection port (instead of the query port).
const char *GetConnectionAddressString() const; const char *GetConnectionAddressString() const;
const char *GetQueryAddressString() const; const char *GetQueryAddressString() const;
// Comparison operators and functions. // Comparison operators and functions.
bool operator<(const servernetadr_t &netadr) const; bool operator<(const servernetadr_t &netadr) const;
void operator=( const servernetadr_t &that ) void operator=( const servernetadr_t &that )
{ {
m_usConnectionPort = that.m_usConnectionPort; m_usConnectionPort = that.m_usConnectionPort;
m_usQueryPort = that.m_usQueryPort; m_usQueryPort = that.m_usQueryPort;
m_unIP = that.m_unIP; m_unIP = that.m_unIP;
} }
private: private:
const char *ToString( uint32 unIP, uint16 usPort ) const; const char *ToString( uint32 unIP, uint16 usPort ) const;
uint16 m_usConnectionPort; // (in HOST byte order) uint16 m_usConnectionPort; // (in HOST byte order)
uint16 m_usQueryPort; uint16 m_usQueryPort;
uint32 m_unIP; uint32 m_unIP;
}; };
inline void servernetadr_t::Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort ) inline void servernetadr_t::Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort )
{ {
m_unIP = ip; m_unIP = ip;
m_usQueryPort = usQueryPort; m_usQueryPort = usQueryPort;
m_usConnectionPort = usConnectionPort; m_usConnectionPort = usConnectionPort;
} }
#ifdef NETADR_H #ifdef NETADR_H
inline netadr_t servernetadr_t::GetIPAndQueryPort() inline netadr_t servernetadr_t::GetIPAndQueryPort()
{ {
return netadr_t( m_unIP, m_usQueryPort ); return netadr_t( m_unIP, m_usQueryPort );
} }
#endif #endif
inline uint16 servernetadr_t::GetQueryPort() const inline uint16 servernetadr_t::GetQueryPort() const
{ {
return m_usQueryPort; return m_usQueryPort;
} }
inline void servernetadr_t::SetQueryPort( uint16 usPort ) inline void servernetadr_t::SetQueryPort( uint16 usPort )
{ {
m_usQueryPort = usPort; m_usQueryPort = usPort;
} }
inline uint16 servernetadr_t::GetConnectionPort() const inline uint16 servernetadr_t::GetConnectionPort() const
{ {
return m_usConnectionPort; return m_usConnectionPort;
} }
inline void servernetadr_t::SetConnectionPort( uint16 usPort ) inline void servernetadr_t::SetConnectionPort( uint16 usPort )
{ {
m_usConnectionPort = usPort; m_usConnectionPort = usPort;
} }
inline uint32 servernetadr_t::GetIP() const inline uint32 servernetadr_t::GetIP() const
{ {
return m_unIP; return m_unIP;
} }
inline void servernetadr_t::SetIP( uint32 unIP ) inline void servernetadr_t::SetIP( uint32 unIP )
{ {
m_unIP = unIP; m_unIP = unIP;
} }
inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const
{ {
static char s[4][64]; static char s[4][64];
static int nBuf = 0; static int nBuf = 0;
unsigned char *ipByte = (unsigned char *)&unIP; unsigned char *ipByte = (unsigned char *)&unIP;
#ifdef VALVE_BIG_ENDIAN #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 ); 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 #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 ); 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 #endif
const char *pchRet = s[nBuf]; const char *pchRet = s[nBuf];
++nBuf; ++nBuf;
nBuf %= ( (sizeof(s)/sizeof(s[0])) ); nBuf %= ( (sizeof(s)/sizeof(s[0])) );
return pchRet; return pchRet;
} }
inline const char* servernetadr_t::GetConnectionAddressString() const inline const char* servernetadr_t::GetConnectionAddressString() const
{ {
return ToString( m_unIP, m_usConnectionPort ); return ToString( m_unIP, m_usConnectionPort );
} }
inline const char* servernetadr_t::GetQueryAddressString() const inline const char* servernetadr_t::GetQueryAddressString() const
{ {
return ToString( m_unIP, m_usQueryPort ); return ToString( m_unIP, m_usQueryPort );
} }
inline bool servernetadr_t::operator<(const servernetadr_t &netadr) const 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 ); return ( m_unIP < netadr.m_unIP ) || ( m_unIP == netadr.m_unIP && m_usQueryPort < netadr.m_usQueryPort );
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Data describing a single server // Purpose: Data describing a single server
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class gameserveritem_t class gameserveritem_t
{ {
public: public:
gameserveritem_t(); gameserveritem_t();
const char* GetName() const; const char* GetName() const;
void SetName( const char *pName ); void SetName( const char *pName );
public: public:
servernetadr_t m_NetAdr; ///< IP/Query Port/Connection Port for this server servernetadr_t m_NetAdr; ///< IP/Query Port/Connection Port for this server
int m_nPing; ///< current ping time in milliseconds int m_nPing; ///< current ping time in milliseconds
bool m_bHadSuccessfulResponse; ///< server has responded successfully in the past 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 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_szGameDir[k_cbMaxGameServerGameDir]; ///< current game directory
char m_szMap[k_cbMaxGameServerMapName]; ///< current map char m_szMap[k_cbMaxGameServerMapName]; ///< current map
char m_szGameDescription[k_cbMaxGameServerGameDescription]; ///< game description char m_szGameDescription[k_cbMaxGameServerGameDescription]; ///< game description
uint32 m_nAppID; ///< Steam App ID of this server uint32 m_nAppID; ///< Steam App ID of this server
int m_nPlayers; ///< total number of players currently on the server. INCLUDES BOTS!! 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_nMaxPlayers; ///< Maximum players that can join this server
int m_nBotPlayers; ///< Number of bots (i.e simulated players) on 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_bPassword; ///< true if this server needs a password to join
bool m_bSecure; ///< Is this server protected by VAC 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) 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 int m_nServerVersion; ///< server version as reported to Steam
private: private:
/// Game server name /// Game server name
char m_szServerName[k_cbMaxGameServerName]; char m_szServerName[k_cbMaxGameServerName];
// For data added after SteamMatchMaking001 add it here // For data added after SteamMatchMaking001 add it here
public: public:
/// the tags this server exposes /// the tags this server exposes
char m_szGameTags[k_cbMaxGameServerTags]; 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) /// steamID of the game server - invalid if it's doesn't have one (old server, or not connected to Steam)
CSteamID m_steamID; CSteamID m_steamID;
}; };
inline gameserveritem_t::gameserveritem_t() inline gameserveritem_t::gameserveritem_t()
{ {
m_szGameDir[0] = m_szMap[0] = m_szGameDescription[0] = m_szServerName[0] = 0; m_szGameDir[0] = m_szMap[0] = m_szGameDescription[0] = m_szServerName[0] = 0;
m_bHadSuccessfulResponse = m_bDoNotRefresh = m_bPassword = m_bSecure = false; 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_nPing = m_nAppID = m_nPlayers = m_nMaxPlayers = m_nBotPlayers = m_ulTimeLastPlayed = m_nServerVersion = 0;
m_szGameTags[0] = 0; m_szGameTags[0] = 0;
} }
inline const char* gameserveritem_t::GetName() const inline const char* gameserveritem_t::GetName() const
{ {
// Use the IP address as the name if nothing is set yet. // Use the IP address as the name if nothing is set yet.
if ( m_szServerName[0] == 0 ) if ( m_szServerName[0] == 0 )
return m_NetAdr.GetConnectionAddressString(); return m_NetAdr.GetConnectionAddressString();
else else
return m_szServerName; return m_szServerName;
} }
inline void gameserveritem_t::SetName( const char *pName ) inline void gameserveritem_t::SetName( const char *pName )
{ {
strncpy( m_szServerName, pName, sizeof( m_szServerName ) ); strncpy( m_szServerName, pName, sizeof( m_szServerName ) );
m_szServerName[ sizeof( m_szServerName ) - 1 ] = '\0'; m_szServerName[ sizeof( m_szServerName ) - 1 ] = '\0';
} }
#endif // MATCHMAKINGTYPES_H #endif // MATCHMAKINGTYPES_H

2546
sdk/steam/steam_api_flat.h
View file

File diff suppressed because it is too large Load diff

890
sdk/steam/steam_api_internal.h
View file

@ -1,445 +1,445 @@
//====== Copyright Valve Corporation, All rights reserved. ==================== //====== Copyright Valve Corporation, All rights reserved. ====================
// //
// Internal implementation details of the steamworks SDK. // Internal implementation details of the steamworks SDK.
// //
// You should be able to figure out how to use the SDK by reading // 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. // steam_api_common.h, and should not need to understand anything in here.
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifdef STEAM_CALLBACK_BEGIN #ifdef STEAM_CALLBACK_BEGIN
#error "This file should only be included from steam_api_common.h" #error "This file should only be included from steam_api_common.h"
#endif #endif
#include <string.h> #include <string.h>
// Internal functions used to locate/create interfaces // Internal functions used to locate/create interfaces
S_API HSteamPipe S_CALLTYPE SteamAPI_GetHSteamPipe(); S_API HSteamPipe S_CALLTYPE SteamAPI_GetHSteamPipe();
S_API HSteamUser S_CALLTYPE SteamAPI_GetHSteamUser(); S_API HSteamUser S_CALLTYPE SteamAPI_GetHSteamUser();
S_API HSteamPipe S_CALLTYPE SteamGameServer_GetHSteamPipe(); S_API HSteamPipe S_CALLTYPE SteamGameServer_GetHSteamPipe();
S_API HSteamUser S_CALLTYPE SteamGameServer_GetHSteamUser(); S_API HSteamUser S_CALLTYPE SteamGameServer_GetHSteamUser();
S_API void *S_CALLTYPE SteamInternal_ContextInit( void *pContextInitData ); 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_CreateInterface( const char *ver );
S_API void *S_CALLTYPE SteamInternal_FindOrCreateUserInterface( HSteamUser hSteamUser, const char *pszVersion ); S_API void *S_CALLTYPE SteamInternal_FindOrCreateUserInterface( HSteamUser hSteamUser, const char *pszVersion );
S_API void *S_CALLTYPE SteamInternal_FindOrCreateGameServerInterface( 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 // 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 // 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. // through a safety function that checks for interfaces being created or destroyed.
// //
// SteamInternal_ContextInit takes a base pointer for the equivalent of // SteamInternal_ContextInit takes a base pointer for the equivalent of
// struct { void (*pFn)(void* pCtx); uintptr_t counter; void *ptr; } // struct { void (*pFn)(void* pCtx); uintptr_t counter; void *ptr; }
// Do not change layout or add non-pointer aligned data! // Do not change layout or add non-pointer aligned data!
#define STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, expr, kind, version ) \ #define STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, expr, kind, version ) \
inline void S_CALLTYPE SteamInternal_Init_ ## name( type *p ) { *p = (type)( expr ); } \ inline void S_CALLTYPE SteamInternal_Init_ ## name( type *p ) { *p = (type)( expr ); } \
STEAM_CLANG_ATTR( "interface_accessor_kind:" kind ";interface_accessor_version:" version ";" ) \ STEAM_CLANG_ATTR( "interface_accessor_kind:" kind ";interface_accessor_version:" version ";" ) \
inline type name() { \ inline type name() { \
static void* s_CallbackCounterAndContext[ 3 ] = { (void*)&SteamInternal_Init_ ## name, 0, 0 }; \ static void* s_CallbackCounterAndContext[ 3 ] = { (void*)&SteamInternal_Init_ ## name, 0, 0 }; \
return *(type*)SteamInternal_ContextInit( s_CallbackCounterAndContext ); \ return *(type*)SteamInternal_ContextInit( s_CallbackCounterAndContext ); \
} }
#define STEAM_DEFINE_USER_INTERFACE_ACCESSOR( type, name, version ) \ #define STEAM_DEFINE_USER_INTERFACE_ACCESSOR( type, name, version ) \
STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, SteamInternal_FindOrCreateUserInterface( SteamAPI_GetHSteamUser(), version ), "user", version ) STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, SteamInternal_FindOrCreateUserInterface( SteamAPI_GetHSteamUser(), version ), "user", version )
#define STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( type, name, version ) \ #define STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( type, name, version ) \
STEAM_DEFINE_INTERFACE_ACCESSOR( type, name, SteamInternal_FindOrCreateGameServerInterface( SteamGameServer_GetHSteamUser(), version ), "gameserver", 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 stuff used for the standard, higher-level callback mechanism
// //
// Internal functions used by the utility CCallback objects to receive callbacks // 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_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback ); S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
// Internal functions used by the utility CCallResult objects to receive async call results // 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_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall ); S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
// disable this warning; this pattern need for steam callback registration // disable this warning; this pattern need for steam callback registration
#ifdef _MSVC_VER #ifdef _MSVC_VER
#pragma warning( push ) #pragma warning( push )
#pragma warning( disable: 4355 ) // 'this' : used in base member initializer list #pragma warning( disable: 4355 ) // 'this' : used in base member initializer list
#endif #endif
#define _STEAM_CALLBACK_OFFSETOF( type, member ) ( (size_t)( (char *)&( (type *)0 )->member ) ) #define _STEAM_CALLBACK_OFFSETOF( type, member ) ( (size_t)( (char *)&( (type *)0 )->member ) )
#define _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) #define _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param )
#define _STEAM_CALLBACK_HELPER( _1, _2, SELECTED, ... ) _STEAM_CALLBACK_##SELECTED #define _STEAM_CALLBACK_HELPER( _1, _2, SELECTED, ... ) _STEAM_CALLBACK_##SELECTED
#define _STEAM_CALLBACK_SELECT( X, Y ) _STEAM_CALLBACK_HELPER X Y #define _STEAM_CALLBACK_SELECT( X, Y ) _STEAM_CALLBACK_HELPER X Y
#define _STEAM_CALLBACK_3( extra_code, thisclass, func, param ) \ #define _STEAM_CALLBACK_3( extra_code, thisclass, func, param ) \
struct CCallbackInternal_ ## func : private CCallbackImpl< sizeof( param ) > { \ struct CCallbackInternal_ ## func : private CCallbackImpl< sizeof( param ) > { \
CCallbackInternal_ ## func () { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \ 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 ( const CCallbackInternal_ ## func & ) { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \
CCallbackInternal_ ## func & operator=( const CCallbackInternal_ ## func & ) { return *this; } \ CCallbackInternal_ ## func & operator=( const CCallbackInternal_ ## func & ) { return *this; } \
private: virtual void Run( void *pvParam ) S_OVERRIDE { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \ private: virtual void Run( void *pvParam ) S_OVERRIDE { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \
thisclass *pOuter = reinterpret_cast<thisclass*>( reinterpret_cast<char*>(this) - _STEAM_CALLBACK_OFFSETOF( thisclass, m_steamcallback_ ## func ) ); \ thisclass *pOuter = reinterpret_cast<thisclass*>( reinterpret_cast<char*>(this) - _STEAM_CALLBACK_OFFSETOF( thisclass, m_steamcallback_ ## func ) ); \
pOuter->func( reinterpret_cast<param*>( pvParam ) ); \ pOuter->func( reinterpret_cast<param*>( pvParam ) ); \
} \ } \
} m_steamcallback_ ## func ; void func( param *pParam ) } m_steamcallback_ ## func ; void func( param *pParam )
#define _STEAM_CALLBACK_4( _, thisclass, func, param, var ) \ #define _STEAM_CALLBACK_4( _, thisclass, func, param, var ) \
CCallback< thisclass, param > var; void func( param *pParam ) CCallback< thisclass, param > var; void func( param *pParam )
#define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \ #define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \
CCallback< thisclass, param, true > var; void func( param *pParam ) CCallback< thisclass, param, true > var; void func( param *pParam )
#ifndef API_GEN #ifndef API_GEN
template< class T, class P > template< class T, class P >
inline CCallResult<T, P>::CCallResult() inline CCallResult<T, P>::CCallResult()
{ {
m_hAPICall = k_uAPICallInvalid; m_hAPICall = k_uAPICallInvalid;
m_pObj = nullptr; m_pObj = nullptr;
m_Func = nullptr; m_Func = nullptr;
m_iCallback = P::k_iCallback; m_iCallback = P::k_iCallback;
} }
template< class T, class P > template< class T, class P >
inline void CCallResult<T, P>::Set( SteamAPICall_t hAPICall, T *p, func_t func ) inline void CCallResult<T, P>::Set( SteamAPICall_t hAPICall, T *p, func_t func )
{ {
if ( m_hAPICall ) if ( m_hAPICall )
SteamAPI_UnregisterCallResult( this, m_hAPICall ); SteamAPI_UnregisterCallResult( this, m_hAPICall );
m_hAPICall = hAPICall; m_hAPICall = hAPICall;
m_pObj = p; m_pObj = p;
m_Func = func; m_Func = func;
if ( hAPICall ) if ( hAPICall )
SteamAPI_RegisterCallResult( this, hAPICall ); SteamAPI_RegisterCallResult( this, hAPICall );
} }
template< class T, class P > template< class T, class P >
inline bool CCallResult<T, P>::IsActive() const inline bool CCallResult<T, P>::IsActive() const
{ {
return (m_hAPICall != k_uAPICallInvalid); return (m_hAPICall != k_uAPICallInvalid);
} }
template< class T, class P > template< class T, class P >
inline void CCallResult<T, P>::Cancel() inline void CCallResult<T, P>::Cancel()
{ {
if ( m_hAPICall != k_uAPICallInvalid ) if ( m_hAPICall != k_uAPICallInvalid )
{ {
SteamAPI_UnregisterCallResult( this, m_hAPICall ); SteamAPI_UnregisterCallResult( this, m_hAPICall );
m_hAPICall = k_uAPICallInvalid; m_hAPICall = k_uAPICallInvalid;
} }
} }
template< class T, class P > template< class T, class P >
inline CCallResult<T, P>::~CCallResult() inline CCallResult<T, P>::~CCallResult()
{ {
Cancel(); Cancel();
} }
template< class T, class P > template< class T, class P >
inline void CCallResult<T, P>::Run( void *pvParam ) inline void CCallResult<T, P>::Run( void *pvParam )
{ {
m_hAPICall = k_uAPICallInvalid; // caller unregisters for us m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
(m_pObj->*m_Func)((P *)pvParam, false); (m_pObj->*m_Func)((P *)pvParam, false);
} }
template< class T, class P > template< class T, class P >
inline void CCallResult<T, P>::Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) inline void CCallResult<T, P>::Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
{ {
if ( hSteamAPICall == m_hAPICall ) if ( hSteamAPICall == m_hAPICall )
{ {
m_hAPICall = k_uAPICallInvalid; // caller unregisters for us m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
(m_pObj->*m_Func)((P *)pvParam, bIOFailure); (m_pObj->*m_Func)((P *)pvParam, bIOFailure);
} }
} }
template< class T, class P, bool bGameserver > template< class T, class P, bool bGameserver >
inline CCallback< T, P, bGameserver >::CCallback( T *pObj, func_t func ) inline CCallback< T, P, bGameserver >::CCallback( T *pObj, func_t func )
: m_pObj( nullptr ), m_Func( nullptr ) : m_pObj( nullptr ), m_Func( nullptr )
{ {
if ( bGameserver ) if ( bGameserver )
{ {
this->SetGameserverFlag(); this->SetGameserverFlag();
} }
Register( pObj, func ); Register( pObj, func );
} }
template< class T, class P, bool bGameserver > template< class T, class P, bool bGameserver >
inline void CCallback< T, P, bGameserver >::Register( T *pObj, func_t func ) inline void CCallback< T, P, bGameserver >::Register( T *pObj, func_t func )
{ {
if ( !pObj || !func ) if ( !pObj || !func )
return; return;
if ( this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered ) if ( this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered )
Unregister(); Unregister();
m_pObj = pObj; m_pObj = pObj;
m_Func = func; m_Func = func;
// SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered // SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered
SteamAPI_RegisterCallback( this, P::k_iCallback ); SteamAPI_RegisterCallback( this, P::k_iCallback );
} }
template< class T, class P, bool bGameserver > template< class T, class P, bool bGameserver >
inline void CCallback< T, P, bGameserver >::Unregister() inline void CCallback< T, P, bGameserver >::Unregister()
{ {
// SteamAPI_UnregisterCallback removes k_ECallbackFlagsRegistered // SteamAPI_UnregisterCallback removes k_ECallbackFlagsRegistered
SteamAPI_UnregisterCallback( this ); SteamAPI_UnregisterCallback( this );
} }
template< class T, class P, bool bGameserver > template< class T, class P, bool bGameserver >
inline void CCallback< T, P, bGameserver >::Run( void *pvParam ) inline void CCallback< T, P, bGameserver >::Run( void *pvParam )
{ {
(m_pObj->*m_Func)((P *)pvParam); (m_pObj->*m_Func)((P *)pvParam);
} }
#endif // #ifndef API_GEN #endif // #ifndef API_GEN
// structure that contains client callback data // structure that contains client callback data
// see callbacks documentation for more details // see callbacks documentation for more details
#if defined( VALVE_CALLBACK_PACK_SMALL ) #if defined( VALVE_CALLBACK_PACK_SMALL )
#pragma pack( push, 4 ) #pragma pack( push, 4 )
#elif defined( VALVE_CALLBACK_PACK_LARGE ) #elif defined( VALVE_CALLBACK_PACK_LARGE )
#pragma pack( push, 8 ) #pragma pack( push, 8 )
#else #else
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
#endif #endif
/// Internal structure used in manual callback dispatch /// Internal structure used in manual callback dispatch
struct CallbackMsg_t struct CallbackMsg_t
{ {
HSteamUser m_hSteamUser; // Specific user to whom this callback applies. 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.) int m_iCallback; // Callback identifier. (Corresponds to the k_iCallback enum in the callback structure.)
uint8 *m_pubParam; // Points to the callback structure uint8 *m_pubParam; // Points to the callback structure
int m_cubParam; // Size of the data pointed to by m_pubParam int m_cubParam; // Size of the data pointed to by m_pubParam
}; };
#pragma pack( pop ) #pragma pack( pop )
// Macros to define steam callback structures. Used internally for debugging // Macros to define steam callback structures. Used internally for debugging
#ifdef STEAM_CALLBACK_INSPECTION_ENABLED #ifdef STEAM_CALLBACK_INSPECTION_ENABLED
#include "../../clientdll/steam_api_callback_inspection.h" #include "../../clientdll/steam_api_callback_inspection.h"
#else #else
#define STEAM_CALLBACK_BEGIN( callbackname, callbackid ) struct callbackname { enum { k_iCallback = callbackid }; #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( varidx, vartype, varname ) vartype varname ;
#define STEAM_CALLBACK_MEMBER_ARRAY( varidx, vartype, varname, varcount ) vartype varname [ varcount ]; #define STEAM_CALLBACK_MEMBER_ARRAY( varidx, vartype, varname, varcount ) vartype varname [ varcount ];
#define STEAM_CALLBACK_END(nArgs) }; #define STEAM_CALLBACK_END(nArgs) };
#endif #endif
// Forward declare all of the Steam interfaces. (Do we really need to do this?) // Forward declare all of the Steam interfaces. (Do we really need to do this?)
class ISteamClient; class ISteamClient;
class ISteamUser; class ISteamUser;
class ISteamGameServer; class ISteamGameServer;
class ISteamFriends; class ISteamFriends;
class ISteamUtils; class ISteamUtils;
class ISteamMatchmaking; class ISteamMatchmaking;
class ISteamContentServer; class ISteamContentServer;
class ISteamMatchmakingServers; class ISteamMatchmakingServers;
class ISteamUserStats; class ISteamUserStats;
class ISteamApps; class ISteamApps;
class ISteamNetworking; class ISteamNetworking;
class ISteamRemoteStorage; class ISteamRemoteStorage;
class ISteamScreenshots; class ISteamScreenshots;
class ISteamMusic; class ISteamMusic;
class ISteamMusicRemote; class ISteamMusicRemote;
class ISteamGameServerStats; class ISteamGameServerStats;
class ISteamHTTP; class ISteamHTTP;
class ISteamController; class ISteamController;
class ISteamUGC; class ISteamUGC;
class ISteamAppList; class ISteamAppList;
class ISteamHTMLSurface; class ISteamHTMLSurface;
class ISteamInventory; class ISteamInventory;
class ISteamVideo; class ISteamVideo;
class ISteamParentalSettings; class ISteamParentalSettings;
class ISteamGameSearch; class ISteamGameSearch;
class ISteamInput; class ISteamInput;
class ISteamParties; class ISteamParties;
class ISteamTV; class ISteamTV;
class ISteamRemotePlay; class ISteamRemotePlay;
// Forward declare types // Forward declare types
struct SteamNetworkingIdentity; struct SteamNetworkingIdentity;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Purpose: Base values for callback identifiers, each callback must // Purpose: Base values for callback identifiers, each callback must
// have a unique ID. // have a unique ID.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
enum { k_iSteamUserCallbacks = 100 }; enum { k_iSteamUserCallbacks = 100 };
enum { k_iSteamGameServerCallbacks = 200 }; enum { k_iSteamGameServerCallbacks = 200 };
enum { k_iSteamFriendsCallbacks = 300 }; enum { k_iSteamFriendsCallbacks = 300 };
enum { k_iSteamBillingCallbacks = 400 }; enum { k_iSteamBillingCallbacks = 400 };
enum { k_iSteamMatchmakingCallbacks = 500 }; enum { k_iSteamMatchmakingCallbacks = 500 };
enum { k_iSteamContentServerCallbacks = 600 }; enum { k_iSteamContentServerCallbacks = 600 };
enum { k_iSteamUtilsCallbacks = 700 }; enum { k_iSteamUtilsCallbacks = 700 };
enum { k_iClientFriendsCallbacks = 800 }; enum { k_iClientFriendsCallbacks = 800 };
enum { k_iClientUserCallbacks = 900 }; enum { k_iClientUserCallbacks = 900 };
enum { k_iSteamAppsCallbacks = 1000 }; enum { k_iSteamAppsCallbacks = 1000 };
enum { k_iSteamUserStatsCallbacks = 1100 }; enum { k_iSteamUserStatsCallbacks = 1100 };
enum { k_iSteamNetworkingCallbacks = 1200 }; enum { k_iSteamNetworkingCallbacks = 1200 };
enum { k_iSteamNetworkingSocketsCallbacks = 1220 }; enum { k_iSteamNetworkingSocketsCallbacks = 1220 };
enum { k_iSteamNetworkingMessagesCallbacks = 1250 }; enum { k_iSteamNetworkingMessagesCallbacks = 1250 };
enum { k_iSteamNetworkingUtilsCallbacks = 1280 }; enum { k_iSteamNetworkingUtilsCallbacks = 1280 };
enum { k_iClientRemoteStorageCallbacks = 1300 }; enum { k_iClientRemoteStorageCallbacks = 1300 };
enum { k_iSteamRemoteStorageCallbacks = 1300 }; enum { k_iSteamRemoteStorageCallbacks = 1300 };
enum { k_iClientDepotBuilderCallbacks = 1400 }; enum { k_iClientDepotBuilderCallbacks = 1400 };
enum { k_iSteamGameServerItemsCallbacks = 1500 }; enum { k_iSteamGameServerItemsCallbacks = 1500 };
enum { k_iClientUtilsCallbacks = 1600 }; enum { k_iClientUtilsCallbacks = 1600 };
enum { k_iSteamGameCoordinatorCallbacks = 1700 }; enum { k_iSteamGameCoordinatorCallbacks = 1700 };
enum { k_iSteamGameServerStatsCallbacks = 1800 }; enum { k_iSteamGameServerStatsCallbacks = 1800 };
enum { k_iSteam2AsyncCallbacks = 1900 }; enum { k_iSteam2AsyncCallbacks = 1900 };
enum { k_iSteamGameStatsCallbacks = 2000 }; enum { k_iSteamGameStatsCallbacks = 2000 };
enum { k_iClientHTTPCallbacks = 2100 }; enum { k_iClientHTTPCallbacks = 2100 };
enum { k_iSteamHTTPCallbacks = 2100 }; enum { k_iSteamHTTPCallbacks = 2100 };
enum { k_iClientScreenshotsCallbacks = 2200 }; enum { k_iClientScreenshotsCallbacks = 2200 };
enum { k_iSteamScreenshotsCallbacks = 2300 }; enum { k_iSteamScreenshotsCallbacks = 2300 };
enum { k_iClientAudioCallbacks = 2400 }; enum { k_iClientAudioCallbacks = 2400 };
enum { k_iClientUnifiedMessagesCallbacks = 2500 }; enum { k_iClientUnifiedMessagesCallbacks = 2500 };
enum { k_iSteamStreamLauncherCallbacks = 2600 }; enum { k_iSteamStreamLauncherCallbacks = 2600 };
enum { k_iClientControllerCallbacks = 2700 }; enum { k_iClientControllerCallbacks = 2700 };
enum { k_iSteamControllerCallbacks = 2800 }; enum { k_iSteamControllerCallbacks = 2800 };
enum { k_iClientParentalSettingsCallbacks = 2900 }; enum { k_iClientParentalSettingsCallbacks = 2900 };
enum { k_iClientDeviceAuthCallbacks = 3000 }; enum { k_iClientDeviceAuthCallbacks = 3000 };
enum { k_iClientNetworkDeviceManagerCallbacks = 3100 }; enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
enum { k_iClientMusicCallbacks = 3200 }; enum { k_iClientMusicCallbacks = 3200 };
enum { k_iClientRemoteClientManagerCallbacks = 3300 }; enum { k_iClientRemoteClientManagerCallbacks = 3300 };
enum { k_iClientUGCCallbacks = 3400 }; enum { k_iClientUGCCallbacks = 3400 };
enum { k_iSteamUGCCallbacks = 3400 }; enum { k_iSteamUGCCallbacks = 3400 };
enum { k_iSteamStreamClientCallbacks = 3500 }; enum { k_iSteamStreamClientCallbacks = 3500 };
enum { k_IClientProductBuilderCallbacks = 3600 }; enum { k_IClientProductBuilderCallbacks = 3600 };
enum { k_iClientShortcutsCallbacks = 3700 }; enum { k_iClientShortcutsCallbacks = 3700 };
enum { k_iClientRemoteControlManagerCallbacks = 3800 }; enum { k_iClientRemoteControlManagerCallbacks = 3800 };
enum { k_iSteamAppListCallbacks = 3900 }; enum { k_iSteamAppListCallbacks = 3900 };
enum { k_iSteamMusicCallbacks = 4000 }; enum { k_iSteamMusicCallbacks = 4000 };
enum { k_iSteamMusicRemoteCallbacks = 4100 }; enum { k_iSteamMusicRemoteCallbacks = 4100 };
enum { k_iClientVRCallbacks = 4200 }; enum { k_iClientVRCallbacks = 4200 };
enum { k_iClientGameNotificationCallbacks = 4300 }; enum { k_iClientGameNotificationCallbacks = 4300 };
enum { k_iSteamGameNotificationCallbacks = 4400 }; enum { k_iSteamGameNotificationCallbacks = 4400 };
enum { k_iSteamHTMLSurfaceCallbacks = 4500 }; enum { k_iSteamHTMLSurfaceCallbacks = 4500 };
enum { k_iClientVideoCallbacks = 4600 }; enum { k_iClientVideoCallbacks = 4600 };
enum { k_iSteamVideoCallbacks = 4600 }; enum { k_iSteamVideoCallbacks = 4600 };
enum { k_iClientInventoryCallbacks = 4700 }; enum { k_iClientInventoryCallbacks = 4700 };
enum { k_iSteamInventoryCallbacks = 4700 }; enum { k_iSteamInventoryCallbacks = 4700 };
enum { k_iClientBluetoothManagerCallbacks = 4800 }; enum { k_iClientBluetoothManagerCallbacks = 4800 };
enum { k_iClientSharedConnectionCallbacks = 4900 }; enum { k_iClientSharedConnectionCallbacks = 4900 };
enum { k_ISteamParentalSettingsCallbacks = 5000 }; enum { k_ISteamParentalSettingsCallbacks = 5000 };
enum { k_iClientShaderCallbacks = 5100 }; enum { k_iClientShaderCallbacks = 5100 };
enum { k_iSteamGameSearchCallbacks = 5200 }; enum { k_iSteamGameSearchCallbacks = 5200 };
enum { k_iSteamPartiesCallbacks = 5300 }; enum { k_iSteamPartiesCallbacks = 5300 };
enum { k_iClientPartiesCallbacks = 5400 }; enum { k_iClientPartiesCallbacks = 5400 };
enum { k_iSteamSTARCallbacks = 5500 }; enum { k_iSteamSTARCallbacks = 5500 };
enum { k_iClientSTARCallbacks = 5600 }; enum { k_iClientSTARCallbacks = 5600 };
enum { k_iSteamRemotePlayCallbacks = 5700 }; enum { k_iSteamRemotePlayCallbacks = 5700 };
enum { k_iClientCompatCallbacks = 5800 }; enum { k_iClientCompatCallbacks = 5800 };
enum { k_iSteamChatCallbacks = 5900 }; enum { k_iSteamChatCallbacks = 5900 };
enum { k_iSteamTimelineCallbacks = 6000 }; // WHY VALVE, WHY? enum { k_iSteamTimelineCallbacks = 6000 }; // WHY VALVE, WHY?
enum { k_iClientNetworkingUtilsCallbacks = 6000 }; enum { k_iClientNetworkingUtilsCallbacks = 6000 };
enum { k_iClientSystemManagerCallbacks = 6100 }; enum { k_iClientSystemManagerCallbacks = 6100 };
enum { k_iClientStorageDeviceManagerCallbacks = 6200 }; enum { k_iClientStorageDeviceManagerCallbacks = 6200 };
#ifdef _MSVC_VER #ifdef _MSVC_VER
#pragma warning( pop ) #pragma warning( pop )
#endif #endif
// Macros used to annotate various Steamworks interfaces to generate the // Macros used to annotate various Steamworks interfaces to generate the
// flat API // flat API
#ifdef API_GEN #ifdef API_GEN
# define STEAM_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR ))) # define STEAM_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
#else #else
# define STEAM_CLANG_ATTR(ATTR) # define STEAM_CLANG_ATTR(ATTR)
#endif #endif
#define STEAM_OUT_STRUCT() STEAM_CLANG_ATTR( "out_struct: ;" ) #define STEAM_OUT_STRUCT() STEAM_CLANG_ATTR( "out_struct: ;" )
#define STEAM_OUT_STRING() STEAM_CLANG_ATTR( "out_string: ;" ) #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_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_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(COUNTER) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";" )
#define STEAM_ARRAY_COUNT_D(COUNTER, DESC) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC ) #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_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_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_OUT_STRING_COUNT(COUNTER) STEAM_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
#define STEAM_DESC(DESC) STEAM_CLANG_ATTR("desc:" #DESC ";") #define STEAM_DESC(DESC) STEAM_CLANG_ATTR("desc:" #DESC ";")
#define STEAM_CALL_RESULT(RESULT_TYPE) STEAM_CLANG_ATTR("callresult:" #RESULT_TYPE ";") #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_CALL_BACK(RESULT_TYPE) STEAM_CLANG_ATTR("callback:" #RESULT_TYPE ";")
#define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";") #define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";")
// CSteamAPIContext encapsulates the Steamworks API global accessors into // CSteamAPIContext encapsulates the Steamworks API global accessors into
// a single object. // a single object.
// //
// DEPRECATED: Used the global interface accessors instead! // DEPRECATED: Used the global interface accessors instead!
// //
// This will be removed in a future iteration of the SDK // This will be removed in a future iteration of the SDK
class CSteamAPIContext class CSteamAPIContext
{ {
public: public:
CSteamAPIContext() { Clear(); } CSteamAPIContext() { Clear(); }
inline void Clear() { memset( this, 0, sizeof(*this) ); } inline void Clear() { memset( this, 0, sizeof(*this) ); }
inline bool Init(); // NOTE: This is defined in steam_api.h, to avoid this file having to include everything inline bool Init(); // NOTE: This is defined in steam_api.h, to avoid this file having to include everything
ISteamClient* SteamClient() const { return m_pSteamClient; } ISteamClient* SteamClient() const { return m_pSteamClient; }
ISteamUser* SteamUser() const { return m_pSteamUser; } ISteamUser* SteamUser() const { return m_pSteamUser; }
ISteamFriends* SteamFriends() const { return m_pSteamFriends; } ISteamFriends* SteamFriends() const { return m_pSteamFriends; }
ISteamUtils* SteamUtils() const { return m_pSteamUtils; } ISteamUtils* SteamUtils() const { return m_pSteamUtils; }
ISteamMatchmaking* SteamMatchmaking() const { return m_pSteamMatchmaking; } ISteamMatchmaking* SteamMatchmaking() const { return m_pSteamMatchmaking; }
ISteamGameSearch* SteamGameSearch() const { return m_pSteamGameSearch; } ISteamGameSearch* SteamGameSearch() const { return m_pSteamGameSearch; }
ISteamUserStats* SteamUserStats() const { return m_pSteamUserStats; } ISteamUserStats* SteamUserStats() const { return m_pSteamUserStats; }
ISteamApps* SteamApps() const { return m_pSteamApps; } ISteamApps* SteamApps() const { return m_pSteamApps; }
ISteamMatchmakingServers* SteamMatchmakingServers() const { return m_pSteamMatchmakingServers; } ISteamMatchmakingServers* SteamMatchmakingServers() const { return m_pSteamMatchmakingServers; }
ISteamNetworking* SteamNetworking() const { return m_pSteamNetworking; } ISteamNetworking* SteamNetworking() const { return m_pSteamNetworking; }
ISteamRemoteStorage* SteamRemoteStorage() const { return m_pSteamRemoteStorage; } ISteamRemoteStorage* SteamRemoteStorage() const { return m_pSteamRemoteStorage; }
ISteamScreenshots* SteamScreenshots() const { return m_pSteamScreenshots; } ISteamScreenshots* SteamScreenshots() const { return m_pSteamScreenshots; }
ISteamHTTP* SteamHTTP() const { return m_pSteamHTTP; } ISteamHTTP* SteamHTTP() const { return m_pSteamHTTP; }
ISteamController* SteamController() const { return m_pController; } ISteamController* SteamController() const { return m_pController; }
ISteamUGC* SteamUGC() const { return m_pSteamUGC; } ISteamUGC* SteamUGC() const { return m_pSteamUGC; }
ISteamAppList* SteamAppList() const { return m_pSteamAppList; } ISteamAppList* SteamAppList() const { return m_pSteamAppList; }
ISteamMusic* SteamMusic() const { return m_pSteamMusic; } ISteamMusic* SteamMusic() const { return m_pSteamMusic; }
ISteamMusicRemote* SteamMusicRemote() const { return m_pSteamMusicRemote; } ISteamMusicRemote* SteamMusicRemote() const { return m_pSteamMusicRemote; }
ISteamHTMLSurface* SteamHTMLSurface() const { return m_pSteamHTMLSurface; } ISteamHTMLSurface* SteamHTMLSurface() const { return m_pSteamHTMLSurface; }
ISteamInventory* SteamInventory() const { return m_pSteamInventory; } ISteamInventory* SteamInventory() const { return m_pSteamInventory; }
ISteamVideo* SteamVideo() const { return m_pSteamVideo; } ISteamVideo* SteamVideo() const { return m_pSteamVideo; }
ISteamTV* SteamTV() const { return m_pSteamTV; } ISteamTV* SteamTV() const { return m_pSteamTV; }
ISteamParentalSettings* SteamParentalSettings() const { return m_pSteamParentalSettings; } ISteamParentalSettings* SteamParentalSettings() const { return m_pSteamParentalSettings; }
ISteamInput* SteamInput() const { return m_pSteamInput; } ISteamInput* SteamInput() const { return m_pSteamInput; }
private: private:
ISteamClient *m_pSteamClient; ISteamClient *m_pSteamClient;
ISteamUser *m_pSteamUser; ISteamUser *m_pSteamUser;
ISteamFriends *m_pSteamFriends; ISteamFriends *m_pSteamFriends;
ISteamUtils *m_pSteamUtils; ISteamUtils *m_pSteamUtils;
ISteamMatchmaking *m_pSteamMatchmaking; ISteamMatchmaking *m_pSteamMatchmaking;
ISteamGameSearch *m_pSteamGameSearch; ISteamGameSearch *m_pSteamGameSearch;
ISteamUserStats *m_pSteamUserStats; ISteamUserStats *m_pSteamUserStats;
ISteamApps *m_pSteamApps; ISteamApps *m_pSteamApps;
ISteamMatchmakingServers *m_pSteamMatchmakingServers; ISteamMatchmakingServers *m_pSteamMatchmakingServers;
ISteamNetworking *m_pSteamNetworking; ISteamNetworking *m_pSteamNetworking;
ISteamRemoteStorage *m_pSteamRemoteStorage; ISteamRemoteStorage *m_pSteamRemoteStorage;
ISteamScreenshots *m_pSteamScreenshots; ISteamScreenshots *m_pSteamScreenshots;
ISteamHTTP *m_pSteamHTTP; ISteamHTTP *m_pSteamHTTP;
ISteamController *m_pController; ISteamController *m_pController;
ISteamUGC *m_pSteamUGC; ISteamUGC *m_pSteamUGC;
ISteamAppList *m_pSteamAppList; ISteamAppList *m_pSteamAppList;
ISteamMusic *m_pSteamMusic; ISteamMusic *m_pSteamMusic;
ISteamMusicRemote *m_pSteamMusicRemote; ISteamMusicRemote *m_pSteamMusicRemote;
ISteamHTMLSurface *m_pSteamHTMLSurface; ISteamHTMLSurface *m_pSteamHTMLSurface;
ISteamInventory *m_pSteamInventory; ISteamInventory *m_pSteamInventory;
ISteamVideo *m_pSteamVideo; ISteamVideo *m_pSteamVideo;
ISteamTV *m_pSteamTV; ISteamTV *m_pSteamTV;
ISteamParentalSettings *m_pSteamParentalSettings; ISteamParentalSettings *m_pSteamParentalSettings;
ISteamInput *m_pSteamInput; ISteamInput *m_pSteamInput;
}; };
class CSteamGameServerAPIContext class CSteamGameServerAPIContext
{ {
public: public:
CSteamGameServerAPIContext() { Clear(); } CSteamGameServerAPIContext() { Clear(); }
inline void Clear() { memset( this, 0, sizeof(*this) ); } 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 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; } ISteamClient *SteamClient() const { return m_pSteamClient; }
ISteamGameServer *SteamGameServer() const { return m_pSteamGameServer; } ISteamGameServer *SteamGameServer() const { return m_pSteamGameServer; }
ISteamUtils *SteamGameServerUtils() const { return m_pSteamGameServerUtils; } ISteamUtils *SteamGameServerUtils() const { return m_pSteamGameServerUtils; }
ISteamNetworking *SteamGameServerNetworking() const { return m_pSteamGameServerNetworking; } ISteamNetworking *SteamGameServerNetworking() const { return m_pSteamGameServerNetworking; }
ISteamGameServerStats *SteamGameServerStats() const { return m_pSteamGameServerStats; } ISteamGameServerStats *SteamGameServerStats() const { return m_pSteamGameServerStats; }
ISteamHTTP *SteamHTTP() const { return m_pSteamHTTP; } ISteamHTTP *SteamHTTP() const { return m_pSteamHTTP; }
ISteamInventory *SteamInventory() const { return m_pSteamInventory; } ISteamInventory *SteamInventory() const { return m_pSteamInventory; }
ISteamUGC *SteamUGC() const { return m_pSteamUGC; } ISteamUGC *SteamUGC() const { return m_pSteamUGC; }
ISteamApps *SteamApps() const { return m_pSteamApps; } ISteamApps *SteamApps() const { return m_pSteamApps; }
private: private:
ISteamClient *m_pSteamClient; ISteamClient *m_pSteamClient;
ISteamGameServer *m_pSteamGameServer; ISteamGameServer *m_pSteamGameServer;
ISteamUtils *m_pSteamGameServerUtils; ISteamUtils *m_pSteamGameServerUtils;
ISteamNetworking *m_pSteamGameServerNetworking; ISteamNetworking *m_pSteamGameServerNetworking;
ISteamGameServerStats *m_pSteamGameServerStats; ISteamGameServerStats *m_pSteamGameServerStats;
ISteamHTTP *m_pSteamHTTP; ISteamHTTP *m_pSteamHTTP;
ISteamInventory *m_pSteamInventory; ISteamInventory *m_pSteamInventory;
ISteamUGC *m_pSteamUGC; ISteamUGC *m_pSteamUGC;
ISteamApps *m_pSteamApps; ISteamApps *m_pSteamApps;
}; };

296
sdk/steam/steam_gameserver.h
View file

@ -1,148 +1,148 @@
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: // Purpose:
// //
//============================================================================= //=============================================================================
#ifndef STEAM_GAMESERVER_H #ifndef STEAM_GAMESERVER_H
#define STEAM_GAMESERVER_H #define STEAM_GAMESERVER_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
#include "steam_api.h" #include "steam_api.h"
#include "isteamgameserver.h" #include "isteamgameserver.h"
#include "isteamgameserverstats.h" #include "isteamgameserverstats.h"
enum EServerMode enum EServerMode
{ {
eServerModeInvalid = 0, // DO NOT USE eServerModeInvalid = 0, // DO NOT USE
eServerModeNoAuthentication = 1, // Don't authenticate user logins and don't list on the server list 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 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 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 /// 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 /// 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 /// 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. /// and ISteamGameServer::GetNextOutgoingPacket to handle packets related to server discovery on your socket.
const uint16 STEAMGAMESERVER_QUERY_PORT_SHARED = 0xffff; const uint16 STEAMGAMESERVER_QUERY_PORT_SHARED = 0xffff;
// DEPRECATED: This old name was really confusing. // DEPRECATED: This old name was really confusing.
#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE ((uint16)-1) #define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE ((uint16)-1)
// Initialize SteamGameServer client and interface objects, and set server properties which may not be changed. // 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 // After calling this function, you should set any additional server parameters, and then
// call ISteamGameServer::LogOnAnonymous() or ISteamGameServer::LogOn() // call ISteamGameServer::LogOnAnonymous() or ISteamGameServer::LogOn()
// //
// - usSteamPort is the local port used to communicate with the steam servers. // - usSteamPort is the local port used to communicate with the steam servers.
// NOTE: unless you are using ver old Steam client binaries, this parameter is ignored, and // NOTE: unless you are using ver old Steam client binaries, this parameter is ignored, and
// you should pass 0. Gameservers now always use WebSockets to talk to Steam. // you should pass 0. Gameservers now always use WebSockets to talk to Steam.
// This protocol is TCP-based and thus always uses an ephemeral local port. // This protocol is TCP-based and thus always uses an ephemeral local port.
// Older steam client binaries used UDP to talk to Steam, and this argument was useful. // Older steam client binaries used UDP to talk to Steam, and this argument was useful.
// A future version of the SDK will remove this argument. // A future version of the SDK will remove this argument.
// - unIP will usually be zero. If you are on a machine with multiple IP addresses, you can pass a non-zero // - 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 // 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. // 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 // - usGamePort is the port that clients will connect to for gameplay. You will usually open up your
// own socket bound to this port. // own socket bound to this port.
// - usQueryPort is the port that will manage server browser related duties and info // - 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 // 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 // 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 // UDP packets for the master server updater. (See ISteamGameServer::HandleIncomingPacket and
// ISteamGameServer::GetNextOutgoingPacket.) // 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 // - 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.) // server is out of date. (Only servers with the latest version will be listed.)
#ifndef STEAM_API_EXPORTS #ifndef STEAM_API_EXPORTS
S_API steam_bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ); S_API steam_bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
S_API ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg ); S_API ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg );
#endif #endif
S_API steam_bool S_CALLTYPE SteamInternal_GameServer_Init( uint32 unIP, uint16 usPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ); S_API steam_bool S_CALLTYPE SteamInternal_GameServer_Init( uint32 unIP, uint16 usPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
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 ); 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 );
// Shutdown SteamGameSeverXxx interfaces, log out, and free resources. // Shutdown SteamGameSeverXxx interfaces, log out, and free resources.
S_API void SteamGameServer_Shutdown(); S_API void SteamGameServer_Shutdown();
// Most Steam API functions allocate some amount of thread-local memory for // Most Steam API functions allocate some amount of thread-local memory for
// parameter storage. Calling SteamGameServer_ReleaseCurrentThreadMemory() // parameter storage. Calling SteamGameServer_ReleaseCurrentThreadMemory()
// will free all API-related memory associated with the calling thread. // will free all API-related memory associated with the calling thread.
// This memory is released automatically by SteamGameServer_RunCallbacks(), // This memory is released automatically by SteamGameServer_RunCallbacks(),
// so single-threaded servers do not need to explicitly call this function. // so single-threaded servers do not need to explicitly call this function.
inline void SteamGameServer_ReleaseCurrentThreadMemory(); inline void SteamGameServer_ReleaseCurrentThreadMemory();
S_API steam_bool SteamGameServer_BSecure(); S_API steam_bool SteamGameServer_BSecure();
S_API uint64 SteamGameServer_GetSteamID(); S_API uint64 SteamGameServer_GetSteamID();
// Older SDKs exported this global pointer, but it is no longer supported. // Older SDKs exported this global pointer, but it is no longer supported.
// You should use SteamGameServerClient() or CSteamGameServerAPIContext to // You should use SteamGameServerClient() or CSteamGameServerAPIContext to
// safely access the ISteamClient APIs from your game server application. // safely access the ISteamClient APIs from your game server application.
//S_API ISteamClient *g_pSteamClientGameServer; //S_API ISteamClient *g_pSteamClientGameServer;
// SteamGameServer_InitSafe has been replaced with SteamGameServer_Init and // SteamGameServer_InitSafe has been replaced with SteamGameServer_Init and
// is no longer supported. Use SteamGameServer_Init instead. // is no longer supported. Use SteamGameServer_Init instead.
//S_API void S_CALLTYPE SteamGameServer_InitSafe(); //S_API void S_CALLTYPE SteamGameServer_InitSafe();
//============================================================================= //=============================================================================
// //
// Internal implementation details below // Internal implementation details below
// //
//============================================================================= //=============================================================================
#ifndef STEAM_API_EXPORTS #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. // 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() inline bool CSteamGameServerAPIContext::Init()
{ {
m_pSteamClient = ::SteamGameServerClient(); m_pSteamClient = ::SteamGameServerClient();
if ( !m_pSteamClient ) if ( !m_pSteamClient )
return false; return false;
m_pSteamGameServer = ::SteamGameServer(); m_pSteamGameServer = ::SteamGameServer();
m_pSteamGameServerUtils = ::SteamGameServerUtils(); m_pSteamGameServerUtils = ::SteamGameServerUtils();
m_pSteamGameServerNetworking = ::SteamGameServerNetworking(); m_pSteamGameServerNetworking = ::SteamGameServerNetworking();
m_pSteamGameServerStats = ::SteamGameServerStats(); m_pSteamGameServerStats = ::SteamGameServerStats();
m_pSteamHTTP = ::SteamGameServerHTTP(); m_pSteamHTTP = ::SteamGameServerHTTP();
m_pSteamInventory = ::SteamGameServerInventory(); m_pSteamInventory = ::SteamGameServerInventory();
m_pSteamUGC = ::SteamGameServerUGC(); m_pSteamUGC = ::SteamGameServerUGC();
m_pSteamApps = ::SteamGameServerApps(); m_pSteamApps = ::SteamGameServerApps();
if ( !m_pSteamGameServer || !m_pSteamGameServerUtils || !m_pSteamGameServerNetworking || !m_pSteamGameServerStats if ( !m_pSteamGameServer || !m_pSteamGameServerUtils || !m_pSteamGameServerNetworking || !m_pSteamGameServerStats
|| !m_pSteamHTTP || !m_pSteamInventory || !m_pSteamUGC || !m_pSteamApps ) || !m_pSteamHTTP || !m_pSteamInventory || !m_pSteamUGC || !m_pSteamApps )
return false; return false;
return true; return true;
} }
inline steam_bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ) inline steam_bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString )
{ {
if ( !SteamInternal_GameServer_Init( unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString ) ) if ( !SteamInternal_GameServer_Init( unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString ) )
return false; return false;
return true; return true;
} }
inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg ) inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg )
{ {
const char *pszInternalCheckInterfaceVersions = const char *pszInternalCheckInterfaceVersions =
STEAMUTILS_INTERFACE_VERSION "\0" STEAMUTILS_INTERFACE_VERSION "\0"
STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0" STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0"
STEAMGAMESERVER_INTERFACE_VERSION "\0" STEAMGAMESERVER_INTERFACE_VERSION "\0"
STEAMGAMESERVERSTATS_INTERFACE_VERSION "\0" STEAMGAMESERVERSTATS_INTERFACE_VERSION "\0"
STEAMHTTP_INTERFACE_VERSION "\0" STEAMHTTP_INTERFACE_VERSION "\0"
STEAMINVENTORY_INTERFACE_VERSION "\0" STEAMINVENTORY_INTERFACE_VERSION "\0"
STEAMNETWORKING_INTERFACE_VERSION "\0" STEAMNETWORKING_INTERFACE_VERSION "\0"
STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0" STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0"
STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0" STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0"
STEAMUGC_INTERFACE_VERSION "\0" STEAMUGC_INTERFACE_VERSION "\0"
"\0"; "\0";
return SteamInternal_GameServer_Init_V2( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, pszInternalCheckInterfaceVersions, pOutErrMsg ); return SteamInternal_GameServer_Init_V2( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, pszInternalCheckInterfaceVersions, pOutErrMsg );
} }
inline void SteamGameServer_ReleaseCurrentThreadMemory() inline void SteamGameServer_ReleaseCurrentThreadMemory()
{ {
SteamAPI_ReleaseCurrentThreadMemory(); SteamAPI_ReleaseCurrentThreadMemory();
} }
#endif #endif
#endif // STEAM_GAMESERVER_H #endif // STEAM_GAMESERVER_H

3176
sdk/steam/steamclientpublic.h
View file

File diff suppressed because it is too large Load diff

80
sdk/steam/steamencryptedappticket.h
View file

@ -1,40 +1,40 @@
//========= Copyright © 1996-2010, Valve LLC, All rights reserved. ============ //========= Copyright © 1996-2010, Valve LLC, All rights reserved. ============
// //
// Purpose: utilities to decode/decrypt a ticket from the // Purpose: utilities to decode/decrypt a ticket from the
// ISteamUser::RequestEncryptedAppTicket, ISteamUser::GetEncryptedAppTicket API // ISteamUser::RequestEncryptedAppTicket, ISteamUser::GetEncryptedAppTicket API
// //
// To use: declare CSteamEncryptedAppTicket, then call BDecryptTicket // To use: declare CSteamEncryptedAppTicket, then call BDecryptTicket
// if BDecryptTicket returns true, other accessors are valid // if BDecryptTicket returns true, other accessors are valid
// //
//============================================================================= //=============================================================================
#include "steam_api.h" #include "steam_api.h"
static const int k_nSteamEncryptedAppTicketSymmetricKeyLen = 32; static const int k_nSteamEncryptedAppTicketSymmetricKeyLen = 32;
S_API bool SteamEncryptedAppTicket_BDecryptTicket( const uint8 *rgubTicketEncrypted, uint32 cubTicketEncrypted, S_API bool SteamEncryptedAppTicket_BDecryptTicket( const uint8 *rgubTicketEncrypted, uint32 cubTicketEncrypted,
uint8 *rgubTicketDecrypted, uint32 *pcubTicketDecrypted, uint8 *rgubTicketDecrypted, uint32 *pcubTicketDecrypted,
const uint8 rgubKey[k_nSteamEncryptedAppTicketSymmetricKeyLen], int cubKey ); const uint8 rgubKey[k_nSteamEncryptedAppTicketSymmetricKeyLen], int cubKey );
S_API bool SteamEncryptedAppTicket_BIsTicketForApp( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID ); S_API bool SteamEncryptedAppTicket_BIsTicketForApp( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID );
S_API RTime32 SteamEncryptedAppTicket_GetTicketIssueTime( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); S_API RTime32 SteamEncryptedAppTicket_GetTicketIssueTime( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
S_API void SteamEncryptedAppTicket_GetTicketSteamID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, CSteamID *psteamID ); S_API void SteamEncryptedAppTicket_GetTicketSteamID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, CSteamID *psteamID );
S_API AppId_t SteamEncryptedAppTicket_GetTicketAppID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); 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_BUserOwnsAppInTicket( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID );
S_API bool SteamEncryptedAppTicket_BUserIsVacBanned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); S_API bool SteamEncryptedAppTicket_BUserIsVacBanned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
S_API bool SteamEncryptedAppTicket_BGetAppDefinedValue( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, uint32 *pValue ); 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 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_BIsTicketSigned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, const uint8 *pubRSAKey, uint32 cubRSAKey );
S_API bool SteamEncryptedAppTicket_BIsLicenseBorrowed( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); S_API bool SteamEncryptedAppTicket_BIsLicenseBorrowed( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
S_API bool SteamEncryptedAppTicket_BIsLicenseTemporary( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted ); S_API bool SteamEncryptedAppTicket_BIsLicenseTemporary( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );

210
sdk/steam/steamhttpenums.h
View file

@ -1,106 +1,106 @@
//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. ======= //====== Copyright © 1996-2010, Valve Corporation, All rights reserved. =======
// //
// Purpose: HTTP related enums, stuff that is shared by both clients and servers, and our // Purpose: HTTP related enums, stuff that is shared by both clients and servers, and our
// UI projects goes here. // UI projects goes here.
// //
//============================================================================= //=============================================================================
#ifndef STEAMHTTPENUMS_H #ifndef STEAMHTTPENUMS_H
#define STEAMHTTPENUMS_H #define STEAMHTTPENUMS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
// HTTP related types // HTTP related types
// This enum is used in client API methods, do not re-number existing values. // This enum is used in client API methods, do not re-number existing values.
enum EHTTPMethod enum EHTTPMethod
{ {
k_EHTTPMethodInvalid = 0, k_EHTTPMethodInvalid = 0,
k_EHTTPMethodGET, k_EHTTPMethodGET,
k_EHTTPMethodHEAD, k_EHTTPMethodHEAD,
k_EHTTPMethodPOST, k_EHTTPMethodPOST,
k_EHTTPMethodPUT, k_EHTTPMethodPUT,
k_EHTTPMethodDELETE, k_EHTTPMethodDELETE,
k_EHTTPMethodOPTIONS, k_EHTTPMethodOPTIONS,
k_EHTTPMethodPATCH, k_EHTTPMethodPATCH,
// The remaining HTTP methods are not yet supported, per rfc2616 section 5.1.1 only GET and HEAD are required for // 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. // a compliant general purpose server. We'll likely add more as we find uses for them.
// k_EHTTPMethodTRACE, // k_EHTTPMethodTRACE,
// k_EHTTPMethodCONNECT // k_EHTTPMethodCONNECT
}; };
// HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions // HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions
// of each of these. // of each of these.
enum EHTTPStatusCode enum EHTTPStatusCode
{ {
// Invalid status code (this isn't defined in HTTP, used to indicate unset in our code) // Invalid status code (this isn't defined in HTTP, used to indicate unset in our code)
k_EHTTPStatusCodeInvalid = 0, k_EHTTPStatusCodeInvalid = 0,
// Informational codes // Informational codes
k_EHTTPStatusCode100Continue = 100, k_EHTTPStatusCode100Continue = 100,
k_EHTTPStatusCode101SwitchingProtocols = 101, k_EHTTPStatusCode101SwitchingProtocols = 101,
// Success codes // Success codes
k_EHTTPStatusCode200OK = 200, k_EHTTPStatusCode200OK = 200,
k_EHTTPStatusCode201Created = 201, k_EHTTPStatusCode201Created = 201,
k_EHTTPStatusCode202Accepted = 202, k_EHTTPStatusCode202Accepted = 202,
k_EHTTPStatusCode203NonAuthoritative = 203, k_EHTTPStatusCode203NonAuthoritative = 203,
k_EHTTPStatusCode204NoContent = 204, k_EHTTPStatusCode204NoContent = 204,
k_EHTTPStatusCode205ResetContent = 205, k_EHTTPStatusCode205ResetContent = 205,
k_EHTTPStatusCode206PartialContent = 206, k_EHTTPStatusCode206PartialContent = 206,
// Redirection codes // Redirection codes
k_EHTTPStatusCode300MultipleChoices = 300, k_EHTTPStatusCode300MultipleChoices = 300,
k_EHTTPStatusCode301MovedPermanently = 301, k_EHTTPStatusCode301MovedPermanently = 301,
k_EHTTPStatusCode302Found = 302, k_EHTTPStatusCode302Found = 302,
k_EHTTPStatusCode303SeeOther = 303, k_EHTTPStatusCode303SeeOther = 303,
k_EHTTPStatusCode304NotModified = 304, k_EHTTPStatusCode304NotModified = 304,
k_EHTTPStatusCode305UseProxy = 305, k_EHTTPStatusCode305UseProxy = 305,
//k_EHTTPStatusCode306Unused = 306, (used in old HTTP spec, now unused in 1.1) //k_EHTTPStatusCode306Unused = 306, (used in old HTTP spec, now unused in 1.1)
k_EHTTPStatusCode307TemporaryRedirect = 307, k_EHTTPStatusCode307TemporaryRedirect = 307,
k_EHTTPStatusCode308PermanentRedirect = 308, k_EHTTPStatusCode308PermanentRedirect = 308,
// Error codes // Error codes
k_EHTTPStatusCode400BadRequest = 400, 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_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_EHTTPStatusCode402PaymentRequired = 402, // This is reserved for future HTTP specs, not really supported by clients
k_EHTTPStatusCode403Forbidden = 403, k_EHTTPStatusCode403Forbidden = 403,
k_EHTTPStatusCode404NotFound = 404, k_EHTTPStatusCode404NotFound = 404,
k_EHTTPStatusCode405MethodNotAllowed = 405, k_EHTTPStatusCode405MethodNotAllowed = 405,
k_EHTTPStatusCode406NotAcceptable = 406, k_EHTTPStatusCode406NotAcceptable = 406,
k_EHTTPStatusCode407ProxyAuthRequired = 407, k_EHTTPStatusCode407ProxyAuthRequired = 407,
k_EHTTPStatusCode408RequestTimeout = 408, k_EHTTPStatusCode408RequestTimeout = 408,
k_EHTTPStatusCode409Conflict = 409, k_EHTTPStatusCode409Conflict = 409,
k_EHTTPStatusCode410Gone = 410, k_EHTTPStatusCode410Gone = 410,
k_EHTTPStatusCode411LengthRequired = 411, k_EHTTPStatusCode411LengthRequired = 411,
k_EHTTPStatusCode412PreconditionFailed = 412, k_EHTTPStatusCode412PreconditionFailed = 412,
k_EHTTPStatusCode413RequestEntityTooLarge = 413, k_EHTTPStatusCode413RequestEntityTooLarge = 413,
k_EHTTPStatusCode414RequestURITooLong = 414, k_EHTTPStatusCode414RequestURITooLong = 414,
k_EHTTPStatusCode415UnsupportedMediaType = 415, k_EHTTPStatusCode415UnsupportedMediaType = 415,
k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416, k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416,
k_EHTTPStatusCode417ExpectationFailed = 417, k_EHTTPStatusCode417ExpectationFailed = 417,
k_EHTTPStatusCode4xxUnknown = 418, // 418 is reserved, so we'll use it to mean unknown k_EHTTPStatusCode4xxUnknown = 418, // 418 is reserved, so we'll use it to mean unknown
k_EHTTPStatusCode429TooManyRequests = 429, k_EHTTPStatusCode429TooManyRequests = 429,
k_EHTTPStatusCode444ConnectionClosed = 444, // nginx only? k_EHTTPStatusCode444ConnectionClosed = 444, // nginx only?
// Server error codes // Server error codes
k_EHTTPStatusCode500InternalServerError = 500, k_EHTTPStatusCode500InternalServerError = 500,
k_EHTTPStatusCode501NotImplemented = 501, k_EHTTPStatusCode501NotImplemented = 501,
k_EHTTPStatusCode502BadGateway = 502, k_EHTTPStatusCode502BadGateway = 502,
k_EHTTPStatusCode503ServiceUnavailable = 503, k_EHTTPStatusCode503ServiceUnavailable = 503,
k_EHTTPStatusCode504GatewayTimeout = 504, k_EHTTPStatusCode504GatewayTimeout = 504,
k_EHTTPStatusCode505HTTPVersionNotSupported = 505, k_EHTTPStatusCode505HTTPVersionNotSupported = 505,
k_EHTTPStatusCode5xxUnknown = 599, k_EHTTPStatusCode5xxUnknown = 599,
}; };
inline bool BIsHTTPStatusSuccess( EHTTPStatusCode eStatus ) inline bool BIsHTTPStatusSuccess( EHTTPStatusCode eStatus )
{ {
return eStatus >= 200 && eStatus <= 299; return eStatus >= 200 && eStatus <= 299;
} }
#endif // STEAMHTTPENUMS_H #endif // STEAMHTTPENUMS_H

224
sdk/steam/steamps3params.h
View file

@ -1,112 +1,112 @@
//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= //====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
// //
// Purpose: // Purpose:
// //
//============================================================================= //=============================================================================
#ifndef STEAMPS3PARAMS_H #ifndef STEAMPS3PARAMS_H
#define STEAMPS3PARAMS_H #define STEAMPS3PARAMS_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
//----------------------------------------------------------------------------------------------------------------------------------------------------------// //----------------------------------------------------------------------------------------------------------------------------------------------------------//
// PlayStation 3 initialization parameters // PlayStation 3 initialization parameters
// //
// The following structure must be passed to when loading steam_api_ps3.prx // The following structure must be passed to when loading steam_api_ps3.prx
//----------------------------------------------------------------------------------------------------------------------------------------------------------// //----------------------------------------------------------------------------------------------------------------------------------------------------------//
#define STEAM_PS3_PATH_MAX 1055 #define STEAM_PS3_PATH_MAX 1055
#define STEAM_PS3_SERVICE_ID_MAX 32 #define STEAM_PS3_SERVICE_ID_MAX 32
#define STEAM_PS3_COMMUNICATION_ID_MAX 10 #define STEAM_PS3_COMMUNICATION_ID_MAX 10
#define STEAM_PS3_COMMUNICATION_SIG_MAX 160 #define STEAM_PS3_COMMUNICATION_SIG_MAX 160
#define STEAM_PS3_LANGUAGE_MAX 64 #define STEAM_PS3_LANGUAGE_MAX 64
#define STEAM_PS3_REGION_CODE_MAX 16 #define STEAM_PS3_REGION_CODE_MAX 16
#define STEAM_PS3_CURRENT_PARAMS_VER 2 #define STEAM_PS3_CURRENT_PARAMS_VER 2
struct SteamPS3Params_t struct SteamPS3Params_t
{ {
uint32 m_unVersion; // set to STEAM_PS3_CURRENT_PARAMS_VER uint32 m_unVersion; // set to STEAM_PS3_CURRENT_PARAMS_VER
void *pReserved; void *pReserved;
uint32 m_nAppId; // set to your game's appid 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_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_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_rgchGameData[ STEAM_PS3_PATH_MAX ]; // persistent game data path for storing user data
char m_rgchNpServiceID[ STEAM_PS3_SERVICE_ID_MAX ]; char m_rgchNpServiceID[ STEAM_PS3_SERVICE_ID_MAX ];
char m_rgchNpCommunicationID[ STEAM_PS3_COMMUNICATION_ID_MAX ]; char m_rgchNpCommunicationID[ STEAM_PS3_COMMUNICATION_ID_MAX ];
char m_rgchNpCommunicationSig[ STEAM_PS3_COMMUNICATION_SIG_MAX ]; char m_rgchNpCommunicationSig[ STEAM_PS3_COMMUNICATION_SIG_MAX ];
// Language should be one of the following. must be zero terminated // Language should be one of the following. must be zero terminated
// danish // danish
// dutch // dutch
// english // english
// finnish // finnish
// french // french
// german // german
// italian // italian
// korean // korean
// norwegian // norwegian
// polish // polish
// portuguese // portuguese
// russian // russian
// schinese // schinese
// spanish // spanish
// swedish // swedish
// tchinese // tchinese
char m_rgchSteamLanguage[ STEAM_PS3_LANGUAGE_MAX ]; char m_rgchSteamLanguage[ STEAM_PS3_LANGUAGE_MAX ];
// region codes are "SCEA", "SCEE", "SCEJ". must be zero terminated // region codes are "SCEA", "SCEE", "SCEJ". must be zero terminated
char m_rgchRegionCode[ STEAM_PS3_REGION_CODE_MAX ]; 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 // 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 // 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. // like: profile_on, profile_off, profile_dump, mem_stats, mem_validate.
unsigned int m_cSteamInputTTY; unsigned int m_cSteamInputTTY;
struct Ps3netInit_t struct Ps3netInit_t
{ {
bool m_bNeedInit; bool m_bNeedInit;
void *m_pMemory; void *m_pMemory;
int m_nMemorySize; int m_nMemorySize;
int m_flags; int m_flags;
} m_sysNetInitInfo; } m_sysNetInitInfo;
struct Ps3jpgInit_t struct Ps3jpgInit_t
{ {
bool m_bNeedInit; bool m_bNeedInit;
} m_sysJpgInitInfo; } m_sysJpgInitInfo;
struct Ps3pngInit_t struct Ps3pngInit_t
{ {
bool m_bNeedInit; bool m_bNeedInit;
} m_sysPngInitInfo; } m_sysPngInitInfo;
struct Ps3sysutilUserInfo_t struct Ps3sysutilUserInfo_t
{ {
bool m_bNeedInit; bool m_bNeedInit;
} m_sysSysUtilUserInfo; } m_sysSysUtilUserInfo;
bool m_bIncludeNewsPage; bool m_bIncludeNewsPage;
}; };
//----------------------------------------------------------------------------------------------------------------------------------------------------------// //----------------------------------------------------------------------------------------------------------------------------------------------------------//
// PlayStation 3 memory structure // PlayStation 3 memory structure
//----------------------------------------------------------------------------------------------------------------------------------------------------------// //----------------------------------------------------------------------------------------------------------------------------------------------------------//
#define STEAMPS3_MALLOC_INUSE 0x53D04A51 #define STEAMPS3_MALLOC_INUSE 0x53D04A51
#define STEAMPS3_MALLOC_SYSTEM 0x0D102C48 #define STEAMPS3_MALLOC_SYSTEM 0x0D102C48
#define STEAMPS3_MALLOC_OK 0xFFD04A51 #define STEAMPS3_MALLOC_OK 0xFFD04A51
struct SteamPS3Memory_t struct SteamPS3Memory_t
{ {
bool m_bSingleAllocation; // If true, Steam will request one 6MB allocation and use the returned memory for all future allocations 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 // If false, Steam will make call malloc for each allocation
// required function pointers // required function pointers
void* (*m_pfMalloc)(size_t); void* (*m_pfMalloc)(size_t);
void* (*m_pfRealloc)(void *, size_t); void* (*m_pfRealloc)(void *, size_t);
void (*m_pfFree)(void *); void (*m_pfFree)(void *);
size_t (*m_pUsable_size)(void*); size_t (*m_pUsable_size)(void*);
}; };
#endif // STEAMPS3PARAMS_H #endif // STEAMPS3PARAMS_H

612
sdk/steam/steamtypes.h
View file

@ -1,306 +1,306 @@
//========= Copyright 1996-2022, Valve LLC, All rights reserved. ============ //========= Copyright 1996-2022, Valve LLC, All rights reserved. ============
#ifndef STEAMTYPES_H #ifndef STEAMTYPES_H
#define STEAMTYPES_H #define STEAMTYPES_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
/* /*
for some dumb reason some games like carrion think a bool is an int and use the whole register as a return value for some dumb reason some games like carrion think a bool is an int and use the whole register as a return value
instead of using just al like a normal program. instead of using just al like a normal program.
*/ */
typedef unsigned steam_bool; typedef unsigned steam_bool;
#define S_CALLTYPE __cdecl #define S_CALLTYPE __cdecl
// Steam-specific types. Defined here so this header file can be included in other code bases. // Steam-specific types. Defined here so this header file can be included in other code bases.
#ifndef WCHARTYPES_H #ifndef WCHARTYPES_H
typedef unsigned char uint8; typedef unsigned char uint8;
#endif #endif
#if defined( __GNUC__ ) && !defined(POSIX) #if defined( __GNUC__ ) && !defined(POSIX)
#if __GNUC__ < 4 #if __GNUC__ < 4
#error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)" #error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)"
#endif #endif
#define POSIX 1 #define POSIX 1
#endif #endif
#if defined(__x86_64__) || defined(_WIN64) || defined(__aarch64__) #if defined(__x86_64__) || defined(_WIN64) || defined(__aarch64__)
#define X64BITS #define X64BITS
#endif #endif
// Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code. // Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code.
#if !defined(VALVE_BIG_ENDIAN) && defined(_PS3) #if !defined(VALVE_BIG_ENDIAN) && defined(_PS3)
#define VALVE_BIG_ENDIAN #define VALVE_BIG_ENDIAN
#endif #endif
typedef unsigned char uint8; typedef unsigned char uint8;
typedef signed char int8; typedef signed char int8;
#if defined( STEAM_WIN32 ) #if defined( STEAM_WIN32 )
typedef __int16 int16; typedef __int16 int16;
typedef unsigned __int16 uint16; typedef unsigned __int16 uint16;
typedef __int32 int32; typedef __int32 int32;
typedef unsigned __int32 uint32; typedef unsigned __int32 uint32;
typedef __int64 int64; typedef __int64 int64;
typedef unsigned __int64 uint64; typedef unsigned __int64 uint64;
typedef int64 lint64; typedef int64 lint64;
typedef uint64 ulint64; typedef uint64 ulint64;
#ifdef X64BITS #ifdef X64BITS
typedef __int64 intp; // intp is an integer that can accomodate a pointer 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 *) typedef unsigned __int64 uintp; // (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
#else #else
typedef __int32 intp; typedef __int32 intp;
typedef unsigned __int32 uintp; typedef unsigned __int32 uintp;
#endif #endif
#else // STEAM_WIN32 #else // STEAM_WIN32
typedef short int16; typedef short int16;
typedef unsigned short uint16; typedef unsigned short uint16;
typedef int int32; typedef int int32;
typedef unsigned int uint32; typedef unsigned int uint32;
typedef long long int64; typedef long long int64;
typedef unsigned long long uint64; typedef unsigned long long uint64;
// [u]int64 are actually defined as 'long long' and gcc 64-bit // [u]int64 are actually defined as 'long long' and gcc 64-bit
// doesn't automatically consider them the same as 'long int'. // doesn't automatically consider them the same as 'long int'.
// Changing the types for [u]int64 is complicated by // Changing the types for [u]int64 is complicated by
// there being many definitions, so we just // there being many definitions, so we just
// define a 'long int' here and use it in places that would // define a 'long int' here and use it in places that would
// otherwise confuse the compiler. // otherwise confuse the compiler.
typedef long int lint64; typedef long int lint64;
typedef unsigned long int ulint64; typedef unsigned long int ulint64;
#ifdef X64BITS #ifdef X64BITS
typedef long long intp; typedef long long intp;
typedef unsigned long long uintp; typedef unsigned long long uintp;
#else #else
typedef int intp; typedef int intp;
typedef unsigned int uintp; typedef unsigned int uintp;
#endif #endif
#endif // else STEAM_WIN32 #endif // else STEAM_WIN32
#ifdef API_GEN #ifdef API_GEN
# define STEAM_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR ))) # define STEAM_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
#else #else
# define STEAM_CLANG_ATTR(ATTR) # define STEAM_CLANG_ATTR(ATTR)
#endif #endif
#define STEAM_METHOD_DESC(DESC) STEAM_CLANG_ATTR( "desc:" #DESC ";" ) #define STEAM_METHOD_DESC(DESC) STEAM_CLANG_ATTR( "desc:" #DESC ";" )
#define STEAM_IGNOREATTR() STEAM_CLANG_ATTR( "ignore" ) #define STEAM_IGNOREATTR() STEAM_CLANG_ATTR( "ignore" )
#define STEAM_OUT_STRUCT() STEAM_CLANG_ATTR( "out_struct: ;" ) #define STEAM_OUT_STRUCT() STEAM_CLANG_ATTR( "out_struct: ;" )
#define STEAM_OUT_STRING() STEAM_CLANG_ATTR( "out_string: ;" ) #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_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_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(COUNTER) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";" )
#define STEAM_ARRAY_COUNT_D(COUNTER, DESC) STEAM_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC ) #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_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_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_OUT_STRING_COUNT(COUNTER) STEAM_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
#define STEAM_DESC(DESC) STEAM_CLANG_ATTR("desc:" #DESC ";") #define STEAM_DESC(DESC) STEAM_CLANG_ATTR("desc:" #DESC ";")
#define STEAM_CALL_RESULT(RESULT_TYPE) STEAM_CLANG_ATTR("callresult:" #RESULT_TYPE ";") #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_CALL_BACK(RESULT_TYPE) STEAM_CLANG_ATTR("callback:" #RESULT_TYPE ";")
#define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";") #define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";")
const int k_cubSaltSize = 8; const int k_cubSaltSize = 8;
typedef uint8 Salt_t[ k_cubSaltSize ]; typedef uint8 Salt_t[ k_cubSaltSize ];
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// GID (GlobalID) stuff // GID (GlobalID) stuff
// This is a globally unique identifier. It's guaranteed to be unique across all // This is a globally unique identifier. It's guaranteed to be unique across all
// racks and servers for as long as a given universe persists. // racks and servers for as long as a given universe persists.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// NOTE: for GID parsing/rendering and other utils, see gid.h // NOTE: for GID parsing/rendering and other utils, see gid.h
typedef uint64 GID_t; typedef uint64 GID_t;
const GID_t k_GIDNil = 0xffffffffffffffffull; const GID_t k_GIDNil = 0xffffffffffffffffull;
// For convenience, we define a number of types that are just new names for GIDs // For convenience, we define a number of types that are just new names for GIDs
typedef uint64 JobID_t; // Each Job has a unique ID typedef uint64 JobID_t; // Each Job has a unique ID
typedef GID_t TxnID_t; // Each financial transaction has a unique ID typedef GID_t TxnID_t; // Each financial transaction has a unique ID
const GID_t k_TxnIDNil = k_GIDNil; const GID_t k_TxnIDNil = k_GIDNil;
const GID_t k_TxnIDUnknown = 0; const GID_t k_TxnIDUnknown = 0;
const JobID_t k_JobIDNil = 0xffffffffffffffffull; const JobID_t k_JobIDNil = 0xffffffffffffffffull;
// this is baked into client messages and interfaces as an int, // this is baked into client messages and interfaces as an int,
// make sure we never break this. // make sure we never break this.
typedef uint32 PackageId_t; typedef uint32 PackageId_t;
const PackageId_t k_uPackageIdFreeSub = 0x0; const PackageId_t k_uPackageIdFreeSub = 0x0;
const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF; const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF;
typedef uint32 BundleId_t; typedef uint32 BundleId_t;
const BundleId_t k_uBundleIdInvalid = 0; const BundleId_t k_uBundleIdInvalid = 0;
// this is baked into client messages and interfaces as an int, // this is baked into client messages and interfaces as an int,
// make sure we never break this. // make sure we never break this.
typedef uint32 AppId_t; typedef uint32 AppId_t;
const AppId_t k_uAppIdInvalid = 0x0; const AppId_t k_uAppIdInvalid = 0x0;
typedef uint64 AssetClassId_t; typedef uint64 AssetClassId_t;
const AssetClassId_t k_ulAssetClassIdInvalid = 0x0; const AssetClassId_t k_ulAssetClassIdInvalid = 0x0;
typedef uint32 PhysicalItemId_t; typedef uint32 PhysicalItemId_t;
const PhysicalItemId_t k_uPhysicalItemIdInvalid = 0x0; const PhysicalItemId_t k_uPhysicalItemIdInvalid = 0x0;
// this is baked into client messages and interfaces as an int, // this is baked into client messages and interfaces as an int,
// make sure we never break this. AppIds and DepotIDs also presently // make sure we never break this. AppIds and DepotIDs also presently
// share the same namespace, but since we'd like to change that in the future // share the same namespace, but since we'd like to change that in the future
// I've defined it seperately here. // I've defined it seperately here.
typedef uint32 DepotId_t; typedef uint32 DepotId_t;
const DepotId_t k_uDepotIdInvalid = 0x0; const DepotId_t k_uDepotIdInvalid = 0x0;
// RTime32 // RTime32
// We use this 32 bit time representing real world time. // We use this 32 bit time representing real world time.
// It offers 1 second resolution beginning on January 1, 1970 (Unix time) // It offers 1 second resolution beginning on January 1, 1970 (Unix time)
typedef uint32 RTime32; typedef uint32 RTime32;
typedef uint32 CellID_t; typedef uint32 CellID_t;
const CellID_t k_uCellIDInvalid = 0xFFFFFFFF; const CellID_t k_uCellIDInvalid = 0xFFFFFFFF;
// handle to a Steam API call // handle to a Steam API call
typedef uint64 SteamAPICall_t; typedef uint64 SteamAPICall_t;
const SteamAPICall_t k_uAPICallInvalid = 0x0; const SteamAPICall_t k_uAPICallInvalid = 0x0;
typedef uint32 AccountID_t; typedef uint32 AccountID_t;
const AccountID_t k_uAccountIdInvalid = 0; const AccountID_t k_uAccountIdInvalid = 0;
typedef uint32 PartnerId_t; typedef uint32 PartnerId_t;
const PartnerId_t k_uPartnerIdInvalid = 0; const PartnerId_t k_uPartnerIdInvalid = 0;
// ID for a depot content manifest // ID for a depot content manifest
typedef uint64 ManifestId_t; typedef uint64 ManifestId_t;
const ManifestId_t k_uManifestIdInvalid = 0; const ManifestId_t k_uManifestIdInvalid = 0;
// ID for cafe sites // ID for cafe sites
typedef uint64 SiteId_t; typedef uint64 SiteId_t;
const SiteId_t k_ulSiteIdInvalid = 0; const SiteId_t k_ulSiteIdInvalid = 0;
#if defined(_WIN32) && defined(__GNUC__) && !defined(_S4N_) #if defined(_WIN32) && defined(__GNUC__) && !defined(_S4N_)
#define STEAMWORKS_STRUCT_RETURN_0(returnType, functionName) \ #define STEAMWORKS_STRUCT_RETURN_0(returnType, functionName) \
virtual void functionName( returnType& ret ) = 0; \ virtual void functionName( returnType& ret ) = 0; \
inline returnType functionName() \ inline returnType functionName() \
{ \ { \
returnType ret; \ returnType ret; \
this->functionName(ret); \ this->functionName(ret); \
return ret; \ return ret; \
} }
#define STEAMWORKS_STRUCT_RETURN_1(returnType, functionName, arg1Type, arg1Name) \ #define STEAMWORKS_STRUCT_RETURN_1(returnType, functionName, arg1Type, arg1Name) \
virtual void functionName( returnType& ret, arg1Type arg1Name ) = 0; \ virtual void functionName( returnType& ret, arg1Type arg1Name ) = 0; \
inline returnType functionName( arg1Type arg1Name ) \ inline returnType functionName( arg1Type arg1Name ) \
{ \ { \
returnType ret; \ returnType ret; \
this->functionName(ret, arg1Name); \ this->functionName(ret, arg1Name); \
return ret; \ return ret; \
} }
#define STEAMWORKS_STRUCT_RETURN_2(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name) \ #define STEAMWORKS_STRUCT_RETURN_2(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name) \
virtual void functionName( returnType& ret, arg1Type arg1Name, arg2Type arg2Name ) = 0; \ virtual void functionName( returnType& ret, arg1Type arg1Name, arg2Type arg2Name ) = 0; \
inline returnType functionName( arg1Type arg1Name, arg2Type arg2Name ) \ inline returnType functionName( arg1Type arg1Name, arg2Type arg2Name ) \
{ \ { \
returnType ret; \ returnType ret; \
this->functionName(ret, arg1Name, arg2Name); \ this->functionName(ret, arg1Name, arg2Name); \
return ret; \ return ret; \
} }
#define STEAMWORKS_STRUCT_RETURN_3(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name, arg3Type, arg3Name) \ #define STEAMWORKS_STRUCT_RETURN_3(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name, arg3Type, arg3Name) \
virtual void functionName( returnType& ret, arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) = 0; \ virtual void functionName( returnType& ret, arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) = 0; \
inline returnType functionName( arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) \ inline returnType functionName( arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) \
{ \ { \
returnType ret; \ returnType ret; \
this->functionName(ret, arg1Name, arg2Name, arg3Name); \ this->functionName(ret, arg1Name, arg2Name, arg3Name); \
return ret; \ return ret; \
} }
#else #else
#define STEAMWORKS_STRUCT_RETURN_0(returnType, functionName) virtual returnType functionName() = 0; #define STEAMWORKS_STRUCT_RETURN_0(returnType, functionName) virtual returnType functionName() = 0;
#define STEAMWORKS_STRUCT_RETURN_1(returnType, functionName, arg1Type, arg1Name) virtual returnType functionName( arg1Type arg1Name ) = 0; #define STEAMWORKS_STRUCT_RETURN_1(returnType, functionName, arg1Type, arg1Name) virtual returnType functionName( arg1Type arg1Name ) = 0;
#define STEAMWORKS_STRUCT_RETURN_2(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name) virtual returnType functionName( arg1Type arg1Name, arg2Type arg2Name ) = 0; #define STEAMWORKS_STRUCT_RETURN_2(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name) virtual returnType functionName( arg1Type arg1Name, arg2Type arg2Name ) = 0;
#define STEAMWORKS_STRUCT_RETURN_3(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name, arg3Type, arg3Name) virtual returnType functionName( arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) = 0; #define STEAMWORKS_STRUCT_RETURN_3(returnType, functionName, arg1Type, arg1Name, arg2Type, arg2Name, arg3Type, arg3Name) virtual returnType functionName( arg1Type arg1Name, arg2Type arg2Name, arg3Type arg3Name ) = 0;
#endif #endif
// Party Beacon ID // Party Beacon ID
typedef uint64 PartyBeaconID_t; typedef uint64 PartyBeaconID_t;
const PartyBeaconID_t k_ulPartyBeaconIdInvalid = 0; const PartyBeaconID_t k_ulPartyBeaconIdInvalid = 0;
enum ESteamIPType enum ESteamIPType
{ {
k_ESteamIPTypeIPv4 = 0, k_ESteamIPTypeIPv4 = 0,
k_ESteamIPTypeIPv6 = 1, k_ESteamIPTypeIPv6 = 1,
}; };
#pragma pack( push, 1 ) #pragma pack( push, 1 )
struct SteamIPAddress_t struct SteamIPAddress_t
{ {
union { union {
uint32 m_unIPv4; // Host order uint32 m_unIPv4; // Host order
uint8 m_rgubIPv6[16]; // Network order! Same as inaddr_in6. (0011:2233:4455:6677:8899:aabb:ccdd:eeff) uint8 m_rgubIPv6[16]; // Network order! Same as inaddr_in6. (0011:2233:4455:6677:8899:aabb:ccdd:eeff)
// Internal use only // Internal use only
uint64 m_ipv6Qword[2]; // big endian uint64 m_ipv6Qword[2]; // big endian
}; };
ESteamIPType m_eType; ESteamIPType m_eType;
bool IsSet() const bool IsSet() const
{ {
if ( k_ESteamIPTypeIPv4 == m_eType ) if ( k_ESteamIPTypeIPv4 == m_eType )
{ {
return m_unIPv4 != 0; return m_unIPv4 != 0;
} }
else else
{ {
return m_ipv6Qword[0] !=0 || m_ipv6Qword[1] != 0; return m_ipv6Qword[0] !=0 || m_ipv6Qword[1] != 0;
} }
} }
static SteamIPAddress_t IPv4Any() static SteamIPAddress_t IPv4Any()
{ {
SteamIPAddress_t ipOut; SteamIPAddress_t ipOut;
ipOut.m_eType = k_ESteamIPTypeIPv4; ipOut.m_eType = k_ESteamIPTypeIPv4;
ipOut.m_unIPv4 = 0; ipOut.m_unIPv4 = 0;
return ipOut; return ipOut;
} }
static SteamIPAddress_t IPv6Any() static SteamIPAddress_t IPv6Any()
{ {
SteamIPAddress_t ipOut; SteamIPAddress_t ipOut;
ipOut.m_eType = k_ESteamIPTypeIPv6; ipOut.m_eType = k_ESteamIPTypeIPv6;
ipOut.m_ipv6Qword[0] = 0; ipOut.m_ipv6Qword[0] = 0;
ipOut.m_ipv6Qword[1] = 0; ipOut.m_ipv6Qword[1] = 0;
return ipOut; return ipOut;
} }
static SteamIPAddress_t IPv4Loopback() static SteamIPAddress_t IPv4Loopback()
{ {
SteamIPAddress_t ipOut; SteamIPAddress_t ipOut;
ipOut.m_eType = k_ESteamIPTypeIPv4; ipOut.m_eType = k_ESteamIPTypeIPv4;
ipOut.m_unIPv4 = 0x7f000001; ipOut.m_unIPv4 = 0x7f000001;
return ipOut; return ipOut;
} }
static SteamIPAddress_t IPv6Loopback() static SteamIPAddress_t IPv6Loopback()
{ {
SteamIPAddress_t ipOut; SteamIPAddress_t ipOut;
ipOut.m_eType = k_ESteamIPTypeIPv6; ipOut.m_eType = k_ESteamIPTypeIPv6;
ipOut.m_ipv6Qword[0] = 0; ipOut.m_ipv6Qword[0] = 0;
ipOut.m_ipv6Qword[1] = 0; ipOut.m_ipv6Qword[1] = 0;
ipOut.m_rgubIPv6[15] = 1; ipOut.m_rgubIPv6[15] = 1;
return ipOut; return ipOut;
} }
}; };
#pragma pack( pop ) #pragma pack( pop )
#endif // STEAMTYPES_H #endif // STEAMTYPES_H

54
sdk/steam/steamuniverse.h
View file

@ -1,27 +1,27 @@
//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ //========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
// //
// Purpose: // Purpose:
// //
//============================================================================= //=============================================================================
#ifndef STEAMUNIVERSE_H #ifndef STEAMUNIVERSE_H
#define STEAMUNIVERSE_H #define STEAMUNIVERSE_H
#ifdef STEAM_WIN32 #ifdef STEAM_WIN32
#pragma once #pragma once
#endif #endif
// Steam universes. Each universe is a self-contained Steam instance. // Steam universes. Each universe is a self-contained Steam instance.
enum EUniverse enum EUniverse
{ {
k_EUniverseInvalid = 0, k_EUniverseInvalid = 0,
k_EUniversePublic = 1, k_EUniversePublic = 1,
k_EUniverseBeta = 2, k_EUniverseBeta = 2,
k_EUniverseInternal = 3, k_EUniverseInternal = 3,
k_EUniverseDev = 4, k_EUniverseDev = 4,
// k_EUniverseRC = 5, // no such universe anymore // k_EUniverseRC = 5, // no such universe anymore
k_EUniverseMax k_EUniverseMax
}; };
#endif // STEAMUNIVERSE_H #endif // STEAMUNIVERSE_H

94
tools/steamclient_loader/linux/README.md
View file

@ -1,47 +1,47 @@
>## How to use it: >## How to use it:
Copy both files Copy both files
- `steamclient.so` - `steamclient.so`
- `steamclient64.so` - `steamclient64.so`
beside the script and specify the requird input, either from commdnline or via the configuration files: `ldr_*.txt` beside the script and specify the requird input, either from commdnline or via the configuration files: `ldr_*.txt`
It is recommended to create a separate setup for each game via the config files It is recommended to create a separate setup for each game via the config files
to avoid specifying the commandline each time. to avoid specifying the commandline each time.
Command line arguments will override the values in the configuration files, Command line arguments will override the values in the configuration files,
with an exception for the arguments passed to the executable, both specified with an exception for the arguments passed to the executable, both specified
in the cofiguration file and via command line will be passed to the executable. in the cofiguration file and via command line will be passed to the executable.
--- ---
>## Command line arguments: >## Command line arguments:
* `-exe`: path to the executable * `-exe`: path to the executable
* `-appid`: numeric app ID * `-appid`: numeric app ID
* `-cwd`: *`(optional)`* working directory to switch to when running the executable * `-cwd`: *`(optional)`* working directory to switch to when running the executable
* `-rt`: *`(optional)`* path to Steam runtime script * `-rt`: *`(optional)`* path to Steam runtime script
- ex1: `~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy.sh` - ex1: `~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy.sh`
- ex2: `~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy/run.sh` - ex2: `~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy/run.sh`
- ex3: `~/.steam/debian-installation/ubuntu12_32/steam-runtime/run.sh` - ex3: `~/.steam/debian-installation/ubuntu12_32/steam-runtime/run.sh`
- ex4: `~/.steam/steam_runtime/run.sh` - ex4: `~/.steam/steam_runtime/run.sh`
* `--`: *`(optional)`* everything after these 2 dashes will be passed directly to the executable" * `--`: *`(optional)`* everything after these 2 dashes will be passed directly to the executable"
**Note** that any unknown args will be passed to the executable **Note** that any unknown args will be passed to the executable
### Examples: ### Examples:
* `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480` * `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480`
* `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -- -opengl` * `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -- -opengl`
* `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -cwd ~/games/mygame/subdir` * `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -cwd ~/games/mygame/subdir`
* `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -rt ~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy/run.sh` * `./steamclient_loader.sh -exe ~/games/mygame/executable -appid 480 -rt ~/.steam/debian-installation/ubuntu12_64/steam-runtime-heavy/run.sh`
--- ---
>## Configuraion files: >## Configuraion files:
Additionally, you can set these values in the equivalent configuration files, Additionally, you can set these values in the equivalent configuration files,
everything on a single line for each file, except `ldr_cmd.txt`: everything on a single line for each file, except `ldr_cmd.txt`:
* `ldr_exe.txt`: specify the executable path in this file * `ldr_exe.txt`: specify the executable path in this file
* `ldr_appid.txt`: specify the app ID in this file * `ldr_appid.txt`: specify the app ID in this file
* `ldr_cwd.txt`: *`(optional)`* specify the working directory of the executable path in this file * `ldr_cwd.txt`: *`(optional)`* specify the working directory of the executable path in this file
* `ldr_steam_rt.txt`: *`(optional)`* specify the path of the Steam runtime script in this file * `ldr_steam_rt.txt`: *`(optional)`* specify the path of the Steam runtime script in this file
* `ldr_cmd.txt`: *`(optional)`* specify aditional arguments that will be passed to the executable in this file, * `ldr_cmd.txt`: *`(optional)`* specify aditional arguments that will be passed to the executable in this file,
this file has the exception that the arguments must be specified on separate lines this file has the exception that the arguments must be specified on separate lines

6
tools/steamclient_loader/linux/ldr_cmdline.EXAMPLE.txt
View file

@ -1,3 +1,3 @@
-steam -steam
-game -game
-vulkan -vulkan

104
tools/steamclient_loader/win/ColdClientLoader.ini
View file

@ -1,52 +1,52 @@
# modified version of ColdClientLoader originally by Rat431 # modified version of ColdClientLoader originally by Rat431
[SteamClient] [SteamClient]
# path to game exe, absolute or relative to the loader # path to game exe, absolute or relative to the loader
Exe=game.exe Exe=game.exe
# empty means the folder of the exe # empty means the folder of the exe
ExeRunDir= ExeRunDir=
# any additional args to pass, ex: -dx11, also any args passed to the loader will be passed to the app # any additional args to pass, ex: -dx11, also any args passed to the loader will be passed to the app
ExeCommandLine= ExeCommandLine=
# IMPORTANT, unless [Persistence] Mode=2 # IMPORTANT, unless [Persistence] Mode=2
AppId= AppId=
# path to the steamclient dlls, both must be set, # path to the steamclient dlls, both must be set,
# absolute paths or relative to the loader # absolute paths or relative to the loader
SteamClientDll=steamclient.dll SteamClientDll=steamclient.dll
SteamClient64Dll=steamclient64.dll SteamClient64Dll=steamclient64.dll
[Injection] [Injection]
# force inject steamclient dll instead of waiting for the app to load it # force inject steamclient dll instead of waiting for the app to load it
ForceInjectSteamClient=0 ForceInjectSteamClient=0
# force inject GameOverlayRenderer dll instead of waiting for the app to load it # force inject GameOverlayRenderer dll instead of waiting for the app to load it
ForceInjectGameOverlayRenderer=0 ForceInjectGameOverlayRenderer=0
# path to a folder containing some dlls to inject into the app upon start, absolute path or relative to this loader # path to a folder containing some dlls to inject into the app upon start, absolute path or relative to this loader
# this folder will be traversed recursively # this folder will be traversed recursively
# additionally, inside this folder you can create a file called `load_order.txt` and # additionally, inside this folder you can create a file called `load_order.txt` and
# specify line by line the order of the dlls that have to be injected # specify line by line the order of the dlls that have to be injected
# each line should be the relative path of the target dll, relative to the injection folder # each line should be the relative path of the target dll, relative to the injection folder
# If this file is created then the loader will only inject the .dll files mentioned inside it # If this file is created then the loader will only inject the .dll files mentioned inside it
# example: # example:
#DllsToInjectFolder=extra_dlls #DllsToInjectFolder=extra_dlls
DllsToInjectFolder= DllsToInjectFolder=
# don't display an error message when a dll injection fails # don't display an error message when a dll injection fails
IgnoreInjectionError=1 IgnoreInjectionError=1
# don't display an error message if the architecture of the loader is different from the app # don't display an error message if the architecture of the loader is different from the app
# this will result in a silent failure if a dll injection didn't succeed # this will result in a silent failure if a dll injection didn't succeed
# both the loader and the app must have the same arch for the injection to work # both the loader and the app must have the same arch for the injection to work
IgnoreLoaderArchDifference=0 IgnoreLoaderArchDifference=0
[Persistence] [Persistence]
# 0 = turned off # 0 = turned off
# 1 = loader will spawn the exe and keep hanging in the background until you press "OK" # 1 = loader will spawn the exe and keep hanging in the background until you press "OK"
# 2 = loader will NOT spawn exe, it will just setup the required environemnt and keep hanging in the background # 2 = loader will NOT spawn exe, it will just setup the required environemnt and keep hanging in the background
# you have to run the Exe manually, and finally press "OK" when you've finished playing # you have to run the Exe manually, and finally press "OK" when you've finished playing
# you have to rename the loader to "steam.exe" # you have to rename the loader to "steam.exe"
# it is advised to run the loader as admin in this mode # it is advised to run the loader as admin in this mode
Mode=0 Mode=0
[Debug] [Debug]
# don't call `ResumeThread()` on the main thread after spawning the .exe # don't call `ResumeThread()` on the main thread after spawning the .exe
ResumeByDebugger=0 ResumeByDebugger=0