mirror of
https://github.com/Facepunch/Facepunch.Steamworks.git
synced 2024-12-25 14:15:47 +03:00
Headers for 1.52
This commit is contained in:
André Straubmeier
parent
59db8fac8a
commit
2f8c19a1d1
@ -373,6 +373,81 @@ enum EControllerActionOrigin
|
||||
k_EControllerActionOrigin_XBoxOne_RightGrip_Upper,
|
||||
k_EControllerActionOrigin_XBoxOne_Share,
|
||||
|
||||
// Added in SDK 1.53
|
||||
k_EControllerActionOrigin_SteamDeck_A,
|
||||
k_EControllerActionOrigin_SteamDeck_B,
|
||||
k_EControllerActionOrigin_SteamDeck_X,
|
||||
k_EControllerActionOrigin_SteamDeck_Y,
|
||||
k_EControllerActionOrigin_SteamDeck_L1,
|
||||
k_EControllerActionOrigin_SteamDeck_R1,
|
||||
k_EControllerActionOrigin_SteamDeck_Menu,
|
||||
k_EControllerActionOrigin_SteamDeck_View,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_Touch,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_Swipe,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_Click,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_DPadNorth,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_DPadSouth,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_DPadWest,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftPad_DPadEast,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_Touch,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_Swipe,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_Click,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_DPadNorth,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_DPadSouth,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_DPadWest,
|
||||
k_EControllerActionOrigin_SteamDeck_RightPad_DPadEast,
|
||||
k_EControllerActionOrigin_SteamDeck_L2_SoftPull,
|
||||
k_EControllerActionOrigin_SteamDeck_L2,
|
||||
k_EControllerActionOrigin_SteamDeck_R2_SoftPull,
|
||||
k_EControllerActionOrigin_SteamDeck_R2,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_Move,
|
||||
k_EControllerActionOrigin_SteamDeck_L3,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_DPadNorth,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_DPadSouth,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_DPadWest,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_DPadEast,
|
||||
k_EControllerActionOrigin_SteamDeck_LeftStick_Touch,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_Move,
|
||||
k_EControllerActionOrigin_SteamDeck_R3,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_DPadNorth,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_DPadSouth,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_DPadWest,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_DPadEast,
|
||||
k_EControllerActionOrigin_SteamDeck_RightStick_Touch,
|
||||
k_EControllerActionOrigin_SteamDeck_L4,
|
||||
k_EControllerActionOrigin_SteamDeck_R4,
|
||||
k_EControllerActionOrigin_SteamDeck_L5,
|
||||
k_EControllerActionOrigin_SteamDeck_R5,
|
||||
k_EControllerActionOrigin_SteamDeck_DPad_Move,
|
||||
k_EControllerActionOrigin_SteamDeck_DPad_North,
|
||||
k_EControllerActionOrigin_SteamDeck_DPad_South,
|
||||
k_EControllerActionOrigin_SteamDeck_DPad_West,
|
||||
k_EControllerActionOrigin_SteamDeck_DPad_East,
|
||||
k_EControllerActionOrigin_SteamDeck_Gyro_Move,
|
||||
k_EControllerActionOrigin_SteamDeck_Gyro_Pitch,
|
||||
k_EControllerActionOrigin_SteamDeck_Gyro_Yaw,
|
||||
k_EControllerActionOrigin_SteamDeck_Gyro_Roll,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved1,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved2,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved3,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved4,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved5,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved6,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved7,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved8,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved9,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved10,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved11,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved12,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved13,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved14,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved15,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved16,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved17,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved18,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved19,
|
||||
k_EControllerActionOrigin_SteamDeck_Reserved20,
|
||||
|
||||
k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
|
||||
k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
|
||||
};
|
||||
|
||||
@ -161,7 +161,7 @@ STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamHTTP *, SteamGameServerHTTP, S
|
||||
|
||||
struct HTTPRequestCompleted_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientHTTPCallbacks + 1 };
|
||||
enum { k_iCallback = k_iSteamHTTPCallbacks + 1 };
|
||||
|
||||
// Handle value for the request that has completed.
|
||||
HTTPRequestHandle m_hRequest;
|
||||
@ -174,6 +174,10 @@ struct HTTPRequestCompleted_t
|
||||
// It will be false if we failed due to an internal error or client side network failure.
|
||||
bool m_bRequestSuccessful;
|
||||
|
||||
bool m_TMP_bSuccessfulA;
|
||||
bool m_TMP_bSuccessfulB;
|
||||
|
||||
|
||||
// Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal
|
||||
// OK response, if you get something else you probably need to treat it as a failure.
|
||||
EHTTPStatusCode m_eStatusCode;
|
||||
@ -184,7 +188,7 @@ struct HTTPRequestCompleted_t
|
||||
|
||||
struct HTTPRequestHeadersReceived_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientHTTPCallbacks + 2 };
|
||||
enum { k_iCallback = k_iSteamHTTPCallbacks + 2 };
|
||||
|
||||
// Handle value for the request that has received headers.
|
||||
HTTPRequestHandle m_hRequest;
|
||||
@ -196,7 +200,7 @@ struct HTTPRequestHeadersReceived_t
|
||||
|
||||
struct HTTPRequestDataReceived_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientHTTPCallbacks + 3 };
|
||||
enum { k_iCallback = k_iSteamHTTPCallbacks + 3 };
|
||||
|
||||
// Handle value for the request that has received data.
|
||||
HTTPRequestHandle m_hRequest;
|
||||
|
||||
@ -407,6 +407,81 @@ enum EInputActionOrigin
|
||||
k_EInputActionOrigin_PS5_Reserved19,
|
||||
k_EInputActionOrigin_PS5_Reserved20,
|
||||
|
||||
// Added in SDK 1.53
|
||||
k_EInputActionOrigin_SteamDeck_A,
|
||||
k_EInputActionOrigin_SteamDeck_B,
|
||||
k_EInputActionOrigin_SteamDeck_X,
|
||||
k_EInputActionOrigin_SteamDeck_Y,
|
||||
k_EInputActionOrigin_SteamDeck_L1,
|
||||
k_EInputActionOrigin_SteamDeck_R1,
|
||||
k_EInputActionOrigin_SteamDeck_Menu,
|
||||
k_EInputActionOrigin_SteamDeck_View,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_Touch,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_Swipe,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_Click,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_DPadNorth,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_DPadSouth,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_DPadWest,
|
||||
k_EInputActionOrigin_SteamDeck_LeftPad_DPadEast,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_Touch,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_Swipe,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_Click,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_DPadNorth,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_DPadSouth,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_DPadWest,
|
||||
k_EInputActionOrigin_SteamDeck_RightPad_DPadEast,
|
||||
k_EInputActionOrigin_SteamDeck_L2_SoftPull,
|
||||
k_EInputActionOrigin_SteamDeck_L2,
|
||||
k_EInputActionOrigin_SteamDeck_R2_SoftPull,
|
||||
k_EInputActionOrigin_SteamDeck_R2,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_Move,
|
||||
k_EInputActionOrigin_SteamDeck_L3,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_DPadNorth,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_DPadSouth,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_DPadWest,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_DPadEast,
|
||||
k_EInputActionOrigin_SteamDeck_LeftStick_Touch,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_Move,
|
||||
k_EInputActionOrigin_SteamDeck_R3,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_DPadNorth,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_DPadSouth,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_DPadWest,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_DPadEast,
|
||||
k_EInputActionOrigin_SteamDeck_RightStick_Touch,
|
||||
k_EInputActionOrigin_SteamDeck_L4,
|
||||
k_EInputActionOrigin_SteamDeck_R4,
|
||||
k_EInputActionOrigin_SteamDeck_L5,
|
||||
k_EInputActionOrigin_SteamDeck_R5,
|
||||
k_EInputActionOrigin_SteamDeck_DPad_Move,
|
||||
k_EInputActionOrigin_SteamDeck_DPad_North,
|
||||
k_EInputActionOrigin_SteamDeck_DPad_South,
|
||||
k_EInputActionOrigin_SteamDeck_DPad_West,
|
||||
k_EInputActionOrigin_SteamDeck_DPad_East,
|
||||
k_EInputActionOrigin_SteamDeck_Gyro_Move,
|
||||
k_EInputActionOrigin_SteamDeck_Gyro_Pitch,
|
||||
k_EInputActionOrigin_SteamDeck_Gyro_Yaw,
|
||||
k_EInputActionOrigin_SteamDeck_Gyro_Roll,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved1,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved2,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved3,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved4,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved5,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved6,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved7,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved8,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved9,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved10,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved11,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved12,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved13,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved14,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved15,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved16,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved17,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved18,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved19,
|
||||
k_EInputActionOrigin_SteamDeck_Reserved20,
|
||||
|
||||
k_EInputActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
|
||||
k_EInputActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
|
||||
};
|
||||
@ -509,6 +584,20 @@ enum ESteamInputGlyphSize
|
||||
k_ESteamInputGlyphSize_Small,
|
||||
k_ESteamInputGlyphSize_Medium,
|
||||
k_ESteamInputGlyphSize_Large,
|
||||
k_ESteamInputGlyphSize_Count,
|
||||
};
|
||||
|
||||
enum ESteamInputGlyphStyle
|
||||
{
|
||||
// Base-styles - cannot mix
|
||||
ESteamInputGlyphStyle_Standard = 0x0,
|
||||
ESteamInputGlyphStyle_Light = 0x1, // Black detail/borders on a white background
|
||||
ESteamInputGlyphStyle_Dark = 0x2, // White detail/borders on a black background
|
||||
|
||||
// Modifiers
|
||||
// Default ABXY/PS equivalent glyphs have a solid fill w/ color matching the physical buttons on the device
|
||||
ESteamInputGlyphStyle_NeutralColorABXY = 0x10, // ABXY Buttons will match the base style color instead of their normal associated color
|
||||
ESteamInputGlyphStyle_OutlineOnlyABXY = 0x20, // ABXY Buttons will have colored outline and label text without fill
|
||||
};
|
||||
|
||||
enum ESteamInputActionEventType
|
||||
@ -577,15 +666,17 @@ struct SteamInputActionEvent_t
|
||||
{
|
||||
InputHandle_t controllerHandle;
|
||||
ESteamInputActionEventType eEventType;
|
||||
struct AnalogAction_t {
|
||||
InputAnalogActionHandle_t actionHandle;
|
||||
InputAnalogActionData_t analogActionData;
|
||||
};
|
||||
struct DigitalAction_t {
|
||||
InputDigitalActionHandle_t actionHandle;
|
||||
InputDigitalActionData_t digitalActionData;
|
||||
};
|
||||
union {
|
||||
struct {
|
||||
InputAnalogActionHandle_t actionHandle;
|
||||
InputAnalogActionData_t analogActionData;
|
||||
} analogAction;
|
||||
struct {
|
||||
InputDigitalActionHandle_t actionHandle;
|
||||
InputDigitalActionData_t digitalActionData;
|
||||
} digitalAction;
|
||||
AnalogAction_t analogAction;
|
||||
DigitalAction_t digitalAction;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
@ -372,7 +372,7 @@ STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamInventory *, SteamGameServerIn
|
||||
// always be exactly one callback per handle.
|
||||
struct SteamInventoryResultReady_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 0 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 0 };
|
||||
SteamInventoryResult_t m_handle;
|
||||
EResult m_result;
|
||||
};
|
||||
@ -387,7 +387,7 @@ struct SteamInventoryResultReady_t
|
||||
// afterwards; this is an additional notification for your convenience.
|
||||
struct SteamInventoryFullUpdate_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 1 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 1 };
|
||||
SteamInventoryResult_t m_handle;
|
||||
};
|
||||
|
||||
@ -398,13 +398,13 @@ struct SteamInventoryFullUpdate_t
|
||||
// a definition update in order to process results from the server.
|
||||
struct SteamInventoryDefinitionUpdate_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 2 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 2 };
|
||||
};
|
||||
|
||||
// Returned
|
||||
struct SteamInventoryEligiblePromoItemDefIDs_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 3 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 3 };
|
||||
EResult m_result;
|
||||
CSteamID m_steamID;
|
||||
int m_numEligiblePromoItemDefs;
|
||||
@ -414,7 +414,7 @@ struct SteamInventoryEligiblePromoItemDefIDs_t
|
||||
// Triggered from StartPurchase call
|
||||
struct SteamInventoryStartPurchaseResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 4 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 4 };
|
||||
EResult m_result;
|
||||
uint64 m_ulOrderID;
|
||||
uint64 m_ulTransID;
|
||||
@ -424,7 +424,7 @@ struct SteamInventoryStartPurchaseResult_t
|
||||
// Triggered from RequestPrices
|
||||
struct SteamInventoryRequestPricesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientInventoryCallbacks + 5 };
|
||||
enum { k_iCallback = k_iSteamInventoryCallbacks + 5 };
|
||||
EResult m_result;
|
||||
char m_rgchCurrency[4];
|
||||
};
|
||||
|
||||
@ -73,10 +73,12 @@ public:
|
||||
///
|
||||
/// Returns:
|
||||
/// - k_EREsultOK on success.
|
||||
/// - k_EResultNoConnection will be returned if the session has failed or was closed by the peer,
|
||||
/// and k_nSteamNetworkingSend_AutoRestartBrokenSession is not used. (You can use
|
||||
/// GetSessionConnectionInfo to get the details.) In order to acknowledge the broken session
|
||||
/// and start a new one, you must call CloseSessionWithUser
|
||||
/// - k_EResultNoConnection, if the session has failed or was closed by the peer and
|
||||
/// k_nSteamNetworkingSend_AutoRestartBrokenSession was not specified. (You can
|
||||
/// use GetSessionConnectionInfo to get the details.) In order to acknowledge the
|
||||
/// broken session and start a new one, you must call CloseSessionWithUser, or you may
|
||||
/// repeat the call with k_nSteamNetworkingSend_AutoRestartBrokenSession. See
|
||||
/// k_nSteamNetworkingSend_AutoRestartBrokenSession for more details.
|
||||
/// - See ISteamNetworkingSockets::SendMessageToConnection for more possible return values
|
||||
virtual EResult SendMessageToUser( const SteamNetworkingIdentity &identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0;
|
||||
|
||||
@ -120,7 +122,7 @@ public:
|
||||
/// you do not need the corresponding details. Note that sessions time out after a while,
|
||||
/// so if a connection fails, or SendMessageToUser returns k_EResultNoConnection, you cannot wait
|
||||
/// indefinitely to obtain the reason for failure.
|
||||
virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetworkingQuickConnectionStatus *pQuickStatus ) = 0;
|
||||
virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetConnectionRealTimeStatus_t *pQuickStatus ) = 0;
|
||||
};
|
||||
#define STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "SteamNetworkingMessages002"
|
||||
|
||||
|
||||
@ -8,8 +8,10 @@
|
||||
#include "steam_api_common.h"
|
||||
|
||||
struct SteamNetAuthenticationStatus_t;
|
||||
struct SteamNetworkingFakeIPResult_t;
|
||||
class ISteamNetworkingConnectionSignaling;
|
||||
class ISteamNetworkingSignalingRecvContext;
|
||||
class ISteamNetworkingFakeUDPPort;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/// Lower level networking API.
|
||||
@ -204,7 +206,7 @@ public:
|
||||
/// WARNING: Be *very careful* when using the value provided in callbacks structs.
|
||||
/// Callbacks are queued, and the value that you will receive in your
|
||||
/// callback is the userdata that was effective at the time the callback
|
||||
/// was queued. There are subtle race conditions that can happen if you
|
||||
/// was queued. There are subtle race conditions that can hapen if you
|
||||
/// don't understand this!
|
||||
///
|
||||
/// If any incoming messages for this connection are queued, the userdata
|
||||
@ -335,8 +337,21 @@ public:
|
||||
virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0;
|
||||
|
||||
/// Returns a small set of information about the real-time state of the connection
|
||||
/// Returns false if the connection handle is invalid, or the connection has ended.
|
||||
virtual bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats ) = 0;
|
||||
/// and the queue status of each lane.
|
||||
///
|
||||
/// - pStatus may be NULL if the information is not desired. (E.g. you are only interested
|
||||
/// in the lane information.)
|
||||
/// - On entry, nLanes specifies the length of the pLanes array. This may be 0
|
||||
/// if you do not wish to receive any lane data. It's OK for this to be smaller than
|
||||
/// the total number of configured lanes.
|
||||
/// - pLanes points to an array that will receive lane-specific info. It can be NULL
|
||||
/// if this is not needed.
|
||||
///
|
||||
/// Return value:
|
||||
/// - k_EResultNoConnection - connection handle is invalid or connection has been closed.
|
||||
/// - k_EResultInvalidParam - nLanes is bad
|
||||
virtual EResult GetConnectionRealTimeStatus( HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t *pStatus,
|
||||
int nLanes, SteamNetConnectionRealTimeLaneStatus_t *pLanes ) = 0;
|
||||
|
||||
/// Returns detailed connection stats in text format. Useful
|
||||
/// for dumping to a log, etc.
|
||||
@ -376,6 +391,80 @@ public:
|
||||
/// actual bound loopback port. Otherwise, the port will be zero.
|
||||
virtual bool CreateSocketPair( HSteamNetConnection *pOutConnection1, HSteamNetConnection *pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity *pIdentity1, const SteamNetworkingIdentity *pIdentity2 ) = 0;
|
||||
|
||||
/// Configure multiple outbound messages streams ("lanes") on a connection, and
|
||||
/// control head-of-line blocking between them. Messages within a given lane
|
||||
/// are always sent in the order they are queued, but messages from different
|
||||
/// lanes may be sent out of order. Each lane has its own message number
|
||||
/// sequence. The first message sent on each lane will be assigned the number 1.
|
||||
///
|
||||
/// Each lane has a "priority". Lower priority lanes will only be processed
|
||||
/// when all higher-priority lanes are empty. The magnitudes of the priority
|
||||
/// values are not relevant, only their sort order. Higher numeric values
|
||||
/// take priority over lower numeric values.
|
||||
///
|
||||
/// Each lane also is assigned a weight, which controls the approximate proportion
|
||||
/// of the bandwidth that will be consumed by the lane, relative to other lanes
|
||||
/// of the same priority. (This is assuming the lane stays busy. An idle lane
|
||||
/// does not build up "credits" to be be spent once a message is queued.)
|
||||
/// This value is only meaningful as a proportion, relative to other lanes with
|
||||
/// the same priority. For lanes with different priorities, the strict priority
|
||||
/// order will prevail, and their weights relative to each other are not relevant.
|
||||
/// Thus, if a lane has a unique priority value, the weight value for that lane is
|
||||
/// not relevant.
|
||||
///
|
||||
/// Example: 3 lanes, with priorities [ 0, 10, 10 ] and weights [ (NA), 20, 5 ].
|
||||
/// Messages sent on the first will always be sent first, before messages in the
|
||||
/// other two lanes. Its weight value is irrelevant, since there are no other
|
||||
/// lanes with priority=0. The other two lanes will share bandwidth, with the second
|
||||
/// and third lanes sharing bandwidth using a ratio of approximately 4:1.
|
||||
/// (The weights [ NA, 4, 1 ] would be equivalent.)
|
||||
///
|
||||
/// Notes:
|
||||
/// - At the time of this writing, some code has performance cost that is linear
|
||||
/// in the number of lanes, so keep the number of lanes to an absolute minimum.
|
||||
/// 3 or so is fine; >8 is a lot. The max number of lanes on Steam is 255,
|
||||
/// which is a very large number and not recommended! If you are compiling this
|
||||
/// library from source, see STEAMNETWORKINGSOCKETS_MAX_LANES.)
|
||||
/// - Lane priority values may be any int. Their absolute value is not relevant,
|
||||
/// only the order matters.
|
||||
/// - Weights must be positive, and due to implementation details, they are restricted
|
||||
/// to 16-bit values. The absolute magnitudes don't matter, just the proportions.
|
||||
/// - Messages sent on a lane index other than 0 have a small overhead on the wire,
|
||||
/// so for maximum wire efficiency, lane 0 should be the "most common" lane, regardless
|
||||
/// of priorities or weights.
|
||||
/// - A connection has a single lane by default. Calling this function with
|
||||
/// nNumLanes=1 is legal, but pointless, since the priority and weight values are
|
||||
/// irrelevant in that case.
|
||||
/// - You may reconfigure connection lanes at any time, however reducing the number of
|
||||
/// lanes is not allowed.
|
||||
/// - Reconfiguring lanes might restart any bandwidth sharing balancing. Usually you
|
||||
/// will call this function once, near the start of the connection, perhaps after
|
||||
/// exchanging a few messages.
|
||||
/// - To assign all lanes the same priority, you may use pLanePriorities=NULL.
|
||||
/// - If you wish all lanes with the same priority to share bandwidth equally (or
|
||||
/// if no two lanes have the same priority value, and thus priority values are
|
||||
/// irrelevant), you may use pLaneWeights=NULL
|
||||
/// - Priorities and weights determine the order that messages are SENT on the wire.
|
||||
/// There are NO GUARANTEES on the order that messages are RECEIVED! Due to packet
|
||||
/// loss, out-of-order delivery, and subtle details of packet serialization, messages
|
||||
/// might still be received slightly out-of-order! The *only* strong guarantee is that
|
||||
/// *reliable* messages on the *same lane* will be delivered in the order they are sent.
|
||||
/// - Each host configures the lanes for the packets they send; the lanes for the flow
|
||||
/// in one direction are completely unrelated to the lanes in the opposite direction.
|
||||
///
|
||||
/// Return value:
|
||||
/// - k_EResultNoConnection - bad hConn
|
||||
/// - k_EResultInvalidParam - Invalid number of lanes, bad weights, or you tried to reduce the number of lanes
|
||||
/// - k_EResultInvalidState - Connection is already dead, etc
|
||||
///
|
||||
/// See also:
|
||||
/// SteamNetworkingMessage_t::m_idxLane
|
||||
virtual EResult ConfigureConnectionLanes( HSteamNetConnection hConn, int nNumLanes, const int *pLanePriorities, const uint16 *pLaneWeights ) = 0;
|
||||
|
||||
//
|
||||
// Identity and authentication
|
||||
//
|
||||
|
||||
/// Get the identity assigned to this interface.
|
||||
/// E.g. on Steam, this is the user's SteamID, or for the gameserver interface, the SteamID assigned
|
||||
/// to the gameserver. Returns false and sets the result to an invalid identity if we don't know
|
||||
@ -690,36 +779,163 @@ public:
|
||||
/// SteamDatagram_CreateCert.
|
||||
virtual bool SetCertificate( const void *pCertificate, int cbCertificate, SteamNetworkingErrMsg &errMsg ) = 0;
|
||||
|
||||
/// Reset the identity associated with this instance.
|
||||
/// Any open connections are closed. Any previous certificates, etc are discarded.
|
||||
/// You can pass a specific identity that you want to use, or you can pass NULL,
|
||||
/// in which case the identity will be invalid until you set it using SetCertificate
|
||||
///
|
||||
/// NOTE: This function is not actually supported on Steam! It is included
|
||||
/// for use on other platforms where the active user can sign out and
|
||||
/// a new user can sign in.
|
||||
virtual void ResetIdentity( const SteamNetworkingIdentity *pIdentity ) = 0;
|
||||
|
||||
//
|
||||
// Misc
|
||||
//
|
||||
|
||||
/// Invoke all callback functions queued for this interface.
|
||||
/// See k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, etc
|
||||
///
|
||||
/// You don't need to call this if you are using Steam's callback dispatch
|
||||
/// mechanism (SteamAPI_RunCallbacks and SteamGameserver_RunCallbacks).
|
||||
virtual void RunCallbacks() = 0;
|
||||
|
||||
//
|
||||
// "FakeIP" system.
|
||||
//
|
||||
// A FakeIP is essentially a temporary, arbitrary identifier that
|
||||
// happens to be a valid IPv4 address. The purpose of this system is to make it
|
||||
// easy to integrate with existing code that identifies hosts using IPv4 addresses.
|
||||
// The FakeIP address will never actually be used to send or receive any packets
|
||||
// on the Internet, it is strictly an identifier.
|
||||
//
|
||||
// FakeIP addresses are designed to (hopefully) pass through existing code as
|
||||
// transparently as possible, while conflicting with "real" addresses that might
|
||||
// be in use on networks (both the Internet and LANs) in the same code as little
|
||||
// as possible. At the time this comment is being written, they come from the
|
||||
// 169.254.0.0/16 range, and the port number will always be >1024. HOWEVER,
|
||||
// this is subject to change! Do not make assumptions about these addresses,
|
||||
// or your code might break in the future. In particular, you should use
|
||||
// functions such as ISteamNetworkingUtils::IsFakeIP to determine if an IP
|
||||
// address is a "fake" one used by this system.
|
||||
//
|
||||
|
||||
/// Begin asynchronous process of allocating a fake IPv4 address that other
|
||||
/// peers can use to contact us via P2P. IP addresses returned by this
|
||||
/// function are globally unique for a given appid.
|
||||
///
|
||||
/// nNumPorts is the numbers of ports you wish to reserve. This is useful
|
||||
/// for the same reason that listening on multiple UDP ports is useful for
|
||||
/// different types of traffic. Because these allocations come from a global
|
||||
/// namespace, there is a relatively strict limit on the maximum number of
|
||||
/// ports you may request. (At the time of this writing, the limit is 4.)
|
||||
/// The Port assignments are *not* guaranteed to have any particular order
|
||||
/// or relationship! Do *not* assume they are contiguous, even though that
|
||||
/// may often occur in practice.
|
||||
///
|
||||
/// Returns false if a request was already in progress, true if a new request
|
||||
/// was started. A SteamNetworkingFakeIP_t will be posted when the request
|
||||
/// completes.
|
||||
///
|
||||
/// You can call this before you are logged in. For gameservers, doing so is
|
||||
/// *required*, and all places where your public IP appears (such as the server
|
||||
/// browser) will be replaced by the FakeIP, and the fake port at index 0.
|
||||
/// A failure will not be posted (using SteamNetworkingFakeIP_t) unless we get
|
||||
/// logged in, and then the request fails. Furthermore, it is assumed that
|
||||
/// FakeIP allocation is essential for your application to function, and so
|
||||
/// failure will not be reported until *several* retries have been attempted,
|
||||
/// possibly lasting several minutes. It is highly recommended to treat failure
|
||||
/// as fatal.
|
||||
///
|
||||
/// To communicate using a connection-oriented (TCP-style) API:
|
||||
/// - Server creates a listen socket using CreateListenSocketP2PFakeIP
|
||||
/// - Client connects using ConnectByIPAddress, passing in the FakeIP address.
|
||||
/// - The connection will behave mostly like a P2P connection. The identities
|
||||
/// that appear in SteamNetConnectionInfo_t will be the FakeIP identity until
|
||||
/// we know the real identity. Then it will be the real identity. If the
|
||||
/// SteamNetConnectionInfo_t::m_addrRemote is valid, it will be a real IPv4
|
||||
/// address of a NAT-punched connection. Otherwise, it will not be valid.
|
||||
///
|
||||
/// To communicate using an ad-hoc sendto/recv from (UDP-style) API,
|
||||
/// use CreateFakeUDPPort.
|
||||
virtual bool BeginAsyncRequestFakeIP( int nNumPorts ) = 0;
|
||||
|
||||
/// Return info about the FakeIP and port(s) that we have been assigned,
|
||||
/// if any. idxFirstPort is currently reserved and must be zero.
|
||||
/// Make sure and check SteamNetworkingFakeIPResult_t::m_eResult
|
||||
virtual void GetFakeIP( int idxFirstPort, SteamNetworkingFakeIPResult_t *pInfo ) = 0;
|
||||
|
||||
/// Create a listen socket that will listen for P2P connections sent
|
||||
/// to our FakeIP. A peer can initiate connections to this listen
|
||||
/// socket by calling ConnectByIPAddress.
|
||||
///
|
||||
/// idxFakePort refers to the *index* of the fake port requested,
|
||||
/// not the actual port number. For example, pass 0 to refer to the
|
||||
/// first port in the reservation. You must call this only after calling
|
||||
/// BeginAsyncRequestFakeIP. However, you do not need to wait for the
|
||||
/// request to complete before creating the listen socket.
|
||||
virtual HSteamListenSocket CreateListenSocketP2PFakeIP( int idxFakePort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
|
||||
|
||||
/// If the connection was initiated using the "FakeIP" system, then we
|
||||
/// we can get an IP address for the remote host. If the remote host had
|
||||
/// a global FakeIP at the time the connection was established, this
|
||||
/// function will return that global IP. Otherwise, a FakeIP that is
|
||||
/// unique locally will be allocated from the local FakeIP address space,
|
||||
/// and that will be returned.
|
||||
///
|
||||
/// The allocation of local FakeIPs attempts to assign addresses in
|
||||
/// a consistent manner. If multiple connections are made to the
|
||||
/// same remote host, they *probably* will return the same FakeIP.
|
||||
/// However, since the namespace is limited, this cannot be guaranteed.
|
||||
///
|
||||
/// On failure, returns:
|
||||
/// - k_EResultInvalidParam: invalid connection handle
|
||||
/// - k_EResultIPNotFound: This connection wasn't made using FakeIP system
|
||||
virtual EResult GetRemoteFakeIPForConnection( HSteamNetConnection hConn, SteamNetworkingIPAddr *pOutAddr ) = 0;
|
||||
|
||||
/// Get an interface that can be used like a UDP port to send/receive
|
||||
/// datagrams to a FakeIP address. This is intended to make it easy
|
||||
/// to port existing UDP-based code to take advantage of SDR.
|
||||
///
|
||||
/// idxFakeServerPort refers to the *index* of the port allocated using
|
||||
/// BeginAsyncRequestFakeIP and is used to create "server" ports. You may
|
||||
/// call this before the allocation has completed. However, any attempts
|
||||
/// to send packets will fail until the allocation has succeeded. When
|
||||
/// the peer receives packets sent from this interface, the from address
|
||||
/// of the packet will be the globally-unique FakeIP. If you call this
|
||||
/// function multiple times and pass the same (nonnegative) fake port index,
|
||||
/// the same object will be returned, and this object is not reference counted.
|
||||
///
|
||||
/// To create a "client" port (e.g. the equivalent of an ephemeral UDP port)
|
||||
/// pass -1. In this case, a distinct object will be returned for each call.
|
||||
/// When the peer receives packets sent from this interface, the peer will
|
||||
/// assign a FakeIP from its own locally-controlled namespace.
|
||||
virtual ISteamNetworkingFakeUDPPort *CreateFakeUDPPort( int idxFakeServerPort ) = 0;
|
||||
|
||||
protected:
|
||||
~ISteamNetworkingSockets(); // Silence some warnings
|
||||
};
|
||||
#define STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "SteamNetworkingSockets009"
|
||||
#define STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "SteamNetworkingSockets012"
|
||||
|
||||
// Global accessors
|
||||
// Using standalone lib
|
||||
#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
|
||||
|
||||
// Standalone lib.
|
||||
static_assert( STEAMNETWORKINGSOCKETS_INTERFACE_VERSION[24] == '9', "Version mismatch" );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets_LibV9();
|
||||
inline ISteamNetworkingSockets *SteamNetworkingSockets_Lib() { return SteamNetworkingSockets_LibV9(); }
|
||||
static_assert( STEAMNETWORKINGSOCKETS_INTERFACE_VERSION[24] == '2', "Version mismatch" );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets_LibV12();
|
||||
inline ISteamNetworkingSockets *SteamNetworkingSockets_Lib() { return SteamNetworkingSockets_LibV12(); }
|
||||
|
||||
// If running in context of steam, we also define a gameserver instance.
|
||||
#ifdef STEAMNETWORKINGSOCKETS_STEAM
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamGameServerNetworkingSockets_LibV9();
|
||||
inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets_Lib() { return SteamGameServerNetworkingSockets_LibV9(); }
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamGameServerNetworkingSockets_LibV12();
|
||||
inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets_Lib() { return SteamGameServerNetworkingSockets_LibV12(); }
|
||||
#endif
|
||||
|
||||
#ifndef STEAMNETWORKINGSOCKETS_STEAMAPI
|
||||
inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_LibV9(); }
|
||||
inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_LibV12(); }
|
||||
#ifdef STEAMNETWORKINGSOCKETS_STEAM
|
||||
inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_LibV9(); }
|
||||
inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_LibV12(); }
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -241,6 +241,32 @@ public:
|
||||
/// Steamworks calls from within the handler.
|
||||
virtual void SetDebugOutputFunction( ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ) = 0;
|
||||
|
||||
//
|
||||
// Fake IP
|
||||
//
|
||||
// Useful for interfacing with code that assumes peers are identified using an IPv4 address
|
||||
//
|
||||
|
||||
/// Return true if an IPv4 address is one that might be used as a "fake" one.
|
||||
/// This function is fast; it just does some logical tests on the IP and does
|
||||
/// not need to do any lookup operations.
|
||||
inline bool IsFakeIPv4( uint32 nIPv4 ) { return GetIPv4FakeIPType( nIPv4 ) > k_ESteamNetworkingFakeIPType_NotFake; }
|
||||
virtual ESteamNetworkingFakeIPType GetIPv4FakeIPType( uint32 nIPv4 ) = 0;
|
||||
|
||||
/// Get the real identity associated with a given FakeIP.
|
||||
///
|
||||
/// On failure, returns:
|
||||
/// - k_EResultInvalidParam: the IP is not a FakeIP.
|
||||
/// - k_EResultNoMatch: we don't recognize that FakeIP and don't know the corresponding identity.
|
||||
///
|
||||
/// FakeIP's used by active connections, or the FakeIPs assigned to local identities,
|
||||
/// will always work. FakeIPs for recently destroyed connections will continue to
|
||||
/// return results for a little while, but not forever. At some point, we will forget
|
||||
/// FakeIPs to save space. It's reasonably safe to assume that you can read back the
|
||||
/// real identity of a connection very soon after it is destroyed. But do not wait
|
||||
/// indefinitely.
|
||||
virtual EResult GetRealIdentityForFakeIP( const SteamNetworkingIPAddr &fakeIP, SteamNetworkingIdentity *pOutRealIdentity ) = 0;
|
||||
|
||||
//
|
||||
// Set and get configuration values, see ESteamNetworkingConfigValue for individual descriptions.
|
||||
//
|
||||
@ -263,6 +289,7 @@ public:
|
||||
bool SetGlobalCallback_SteamNetConnectionStatusChanged( FnSteamNetConnectionStatusChanged fnCallback );
|
||||
bool SetGlobalCallback_SteamNetAuthenticationStatusChanged( FnSteamNetAuthenticationStatusChanged fnCallback );
|
||||
bool SetGlobalCallback_SteamRelayNetworkStatusChanged( FnSteamRelayNetworkStatusChanged fnCallback );
|
||||
bool SetGlobalCallback_FakeIPResult( FnSteamNetworkingFakeIPResult fnCallback );
|
||||
bool SetGlobalCallback_MessagesSessionRequest( FnSteamNetworkingMessagesSessionRequest fnCallback );
|
||||
bool SetGlobalCallback_MessagesSessionFailed( FnSteamNetworkingMessagesSessionFailed fnCallback );
|
||||
|
||||
@ -295,41 +322,48 @@ public:
|
||||
virtual ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj,
|
||||
ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult ) = 0;
|
||||
|
||||
/// Returns info about a configuration value. Returns false if the value does not exist.
|
||||
/// pOutNextValue can be used to iterate through all of the known configuration values.
|
||||
/// (Use GetFirstConfigValue() to begin the iteration, will be k_ESteamNetworkingConfig_Invalid on the last value)
|
||||
/// Any of the output parameters can be NULL if you do not need that information.
|
||||
/// Get info about a configuration value. Returns the name of the value,
|
||||
/// or NULL if the value doesn't exist. Other output parameters can be NULL
|
||||
/// if you do not need them.
|
||||
virtual const char *GetConfigValueInfo( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigDataType *pOutDataType,
|
||||
ESteamNetworkingConfigScope *pOutScope ) = 0;
|
||||
|
||||
/// Iterate the list of all configuration values in the current environment that it might
|
||||
/// be possible to display or edit using a generic UI. To get the first iterable value,
|
||||
/// pass k_ESteamNetworkingConfig_Invalid. Returns k_ESteamNetworkingConfig_Invalid
|
||||
/// to signal end of list.
|
||||
///
|
||||
/// See k_ESteamNetworkingConfig_EnumerateDevVars for some more info about "dev" variables,
|
||||
/// which are usually excluded from the set of variables enumerated using this function.
|
||||
virtual bool GetConfigValueInfo( ESteamNetworkingConfigValue eValue, const char **pOutName, ESteamNetworkingConfigDataType *pOutDataType, ESteamNetworkingConfigScope *pOutScope, ESteamNetworkingConfigValue *pOutNextValue ) = 0;
|
||||
|
||||
/// Return the lowest numbered configuration value available in the current environment.
|
||||
virtual ESteamNetworkingConfigValue GetFirstConfigValue() = 0;
|
||||
/// The bEnumerateDevVars argument can be used to include "dev" vars. These are vars that
|
||||
/// are recommended to only be editable in "debug" or "dev" mode and typically should not be
|
||||
/// shown in a retail environment where a malicious local user might use this to cheat.
|
||||
virtual ESteamNetworkingConfigValue IterateGenericEditableConfigValues( ESteamNetworkingConfigValue eCurrent, bool bEnumerateDevVars ) = 0;
|
||||
|
||||
//
|
||||
// String conversions. You'll usually access these using the respective
|
||||
// inline methods.
|
||||
//
|
||||
virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort ) = 0;
|
||||
virtual bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ) = 0;
|
||||
virtual ESteamNetworkingFakeIPType SteamNetworkingIPAddr_GetFakeIPType( const SteamNetworkingIPAddr &addr ) = 0;
|
||||
virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf ) = 0;
|
||||
virtual bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr ) = 0;
|
||||
|
||||
protected:
|
||||
~ISteamNetworkingUtils(); // Silence some warnings
|
||||
};
|
||||
#define STEAMNETWORKINGUTILS_INTERFACE_VERSION "SteamNetworkingUtils003"
|
||||
#define STEAMNETWORKINGUTILS_INTERFACE_VERSION "SteamNetworkingUtils004"
|
||||
|
||||
// Global accessors
|
||||
// Using standalone lib
|
||||
#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
|
||||
|
||||
// Standalone lib
|
||||
static_assert( STEAMNETWORKINGUTILS_INTERFACE_VERSION[22] == '3', "Version mismatch" );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils_LibV3();
|
||||
inline ISteamNetworkingUtils *SteamNetworkingUtils_Lib() { return SteamNetworkingUtils_LibV3(); }
|
||||
static_assert( STEAMNETWORKINGUTILS_INTERFACE_VERSION[22] == '4', "Version mismatch" );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils_LibV4();
|
||||
inline ISteamNetworkingUtils *SteamNetworkingUtils_Lib() { return SteamNetworkingUtils_LibV4(); }
|
||||
|
||||
#ifndef STEAMNETWORKINGSOCKETS_STEAMAPI
|
||||
inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_LibV3(); }
|
||||
inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_LibV4(); }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -385,6 +419,8 @@ struct SteamRelayNetworkStatus_t
|
||||
char m_debugMsg[ 256 ];
|
||||
};
|
||||
|
||||
#ifndef API_GEN
|
||||
|
||||
/// Utility class for printing a SteamNetworkingIdentity.
|
||||
/// E.g. printf( "Identity is '%s'\n", SteamNetworkingIdentityRender( identity ).c_str() );
|
||||
struct SteamNetworkingIdentityRender
|
||||
@ -404,6 +440,8 @@ private:
|
||||
char buf[ SteamNetworkingIPAddr::k_cchMaxString ];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Internal stuff
|
||||
@ -419,6 +457,7 @@ inline bool ISteamNetworkingUtils::SetConnectionConfigValueString( HSteamNetConn
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamNetConnectionStatusChanged( FnSteamNetConnectionStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, (void*)fnCallback ); }
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamNetAuthenticationStatusChanged( FnSteamNetAuthenticationStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_AuthStatusChanged, (void*)fnCallback ); }
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_SteamRelayNetworkStatusChanged( FnSteamRelayNetworkStatusChanged fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged, (void*)fnCallback ); }
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_FakeIPResult( FnSteamNetworkingFakeIPResult fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_FakeIPResult, (void*)fnCallback ); }
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionRequest( FnSteamNetworkingMessagesSessionRequest fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_MessagesSessionRequest, (void*)fnCallback ); }
|
||||
inline bool ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionFailed( FnSteamNetworkingMessagesSessionFailed fnCallback ) { return SetGlobalConfigValuePtr( k_ESteamNetworkingConfig_Callback_MessagesSessionFailed, (void*)fnCallback ); }
|
||||
|
||||
@ -433,15 +472,17 @@ inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingCo
|
||||
}
|
||||
|
||||
// How to get helper functions.
|
||||
#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || defined( STEAMNETWORKINGSOCKETS_STANDALONELIB )
|
||||
#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || defined(STEAMNETWORKINGSOCKETS_FOREXPORT) || defined( STEAMNETWORKINGSOCKETS_STANDALONELIB )
|
||||
|
||||
// Call direct to static functions
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE ESteamNetworkingFakeIPType SteamNetworkingIPAddr_GetFakeIPType( const SteamNetworkingIPAddr *pAddr );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity *pIdentity, char *buf, size_t cbBuf );
|
||||
STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr );
|
||||
inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); }
|
||||
inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingIPAddr_ParseString( this, pszStr ); }
|
||||
inline ESteamNetworkingFakeIPType SteamNetworkingIPAddr::GetFakeIPType() const { return SteamNetworkingIPAddr_GetFakeIPType( this ); }
|
||||
inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingIdentity_ToString( this, buf, cbBuf ); }
|
||||
inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingIdentity_ParseString( this, sizeof(*this), pszStr ); }
|
||||
|
||||
@ -449,6 +490,7 @@ inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingCo
|
||||
// Using steamworks SDK - go through SteamNetworkingUtils()
|
||||
inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); }
|
||||
inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); }
|
||||
inline ESteamNetworkingFakeIPType SteamNetworkingIPAddr::GetFakeIPType() const { return SteamNetworkingUtils()->SteamNetworkingIPAddr_GetFakeIPType( *this ); }
|
||||
inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
|
||||
inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); }
|
||||
#else
|
||||
|
||||
@ -337,24 +337,20 @@ STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamRemoteStorage *, SteamRemoteStorage,
|
||||
|
||||
|
||||
|
||||
//
|
||||
// IMPORTANT! k_iClientRemoteStorageCallbacks 1 through 6 are used, see iclientremotestorage.h
|
||||
//
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: The result of a call to FileShare()
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageFileShareResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 7 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 7 };
|
||||
EResult m_eResult; // The result of the operation
|
||||
UGCHandle_t m_hFile; // The handle that can be shared with users and features
|
||||
char m_rgchFilename[k_cchFilenameMax]; // The name of the file that was shared
|
||||
};
|
||||
|
||||
|
||||
// k_iClientRemoteStorageCallbacks + 8 is deprecated! Do not reuse
|
||||
// k_iSteamRemoteStorageCallbacks + 8 is deprecated! Do not reuse
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
@ -362,13 +358,13 @@ struct RemoteStorageFileShareResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishFileResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 9 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 9 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
|
||||
};
|
||||
|
||||
// k_iClientRemoteStorageCallbacks + 10 is deprecated! Do not reuse
|
||||
// k_iSteamRemoteStorageCallbacks + 10 is deprecated! Do not reuse
|
||||
|
||||
|
||||
|
||||
@ -377,7 +373,7 @@ struct RemoteStoragePublishFileResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageDeletePublishedFileResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 11 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 11 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
};
|
||||
@ -388,7 +384,7 @@ struct RemoteStorageDeletePublishedFileResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageEnumerateUserPublishedFilesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 12 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 12 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
int32 m_nResultsReturned;
|
||||
int32 m_nTotalResultCount;
|
||||
@ -401,7 +397,7 @@ struct RemoteStorageEnumerateUserPublishedFilesResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageSubscribePublishedFileResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 13 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 13 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
};
|
||||
@ -412,7 +408,7 @@ struct RemoteStorageSubscribePublishedFileResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageEnumerateUserSubscribedFilesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 14 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 14 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
int32 m_nResultsReturned;
|
||||
int32 m_nTotalResultCount;
|
||||
@ -433,7 +429,7 @@ struct RemoteStorageEnumerateUserSubscribedFilesResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageUnsubscribePublishedFileResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 15 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 15 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
};
|
||||
@ -444,7 +440,7 @@ struct RemoteStorageUnsubscribePublishedFileResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageUpdatePublishedFileResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 16 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 16 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
|
||||
@ -456,7 +452,7 @@ struct RemoteStorageUpdatePublishedFileResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageDownloadUGCResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 17 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 17 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
UGCHandle_t m_hFile; // The handle to the file that was attempted to be downloaded.
|
||||
AppId_t m_nAppID; // ID of the app that created this file.
|
||||
@ -471,7 +467,7 @@ struct RemoteStorageDownloadUGCResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageGetPublishedFileDetailsResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 18 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 18 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
AppId_t m_nCreatorAppID; // ID of the app that created this file.
|
||||
@ -498,7 +494,7 @@ struct RemoteStorageGetPublishedFileDetailsResult_t
|
||||
|
||||
struct RemoteStorageEnumerateWorkshopFilesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 19 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 19 };
|
||||
EResult m_eResult;
|
||||
int32 m_nResultsReturned;
|
||||
int32 m_nTotalResultCount;
|
||||
@ -514,7 +510,7 @@ struct RemoteStorageEnumerateWorkshopFilesResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageGetPublishedItemVoteDetailsResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 20 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 20 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_unPublishedFileId;
|
||||
int32 m_nVotesFor;
|
||||
@ -529,7 +525,7 @@ struct RemoteStorageGetPublishedItemVoteDetailsResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishedFileSubscribed_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 21 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 21 };
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
AppId_t m_nAppID; // ID of the app that will consume this file.
|
||||
};
|
||||
@ -539,7 +535,7 @@ struct RemoteStoragePublishedFileSubscribed_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishedFileUnsubscribed_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 22 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 22 };
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
AppId_t m_nAppID; // ID of the app that will consume this file.
|
||||
};
|
||||
@ -550,7 +546,7 @@ struct RemoteStoragePublishedFileUnsubscribed_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishedFileDeleted_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 23 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 23 };
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
AppId_t m_nAppID; // ID of the app that will consume this file.
|
||||
};
|
||||
@ -561,7 +557,7 @@ struct RemoteStoragePublishedFileDeleted_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageUpdateUserPublishedItemVoteResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 24 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 24 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
};
|
||||
@ -572,7 +568,7 @@ struct RemoteStorageUpdateUserPublishedItemVoteResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageUserVoteDetails_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 25 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 25 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
EWorkshopVote m_eVote; // what the user voted
|
||||
@ -580,7 +576,7 @@ struct RemoteStorageUserVoteDetails_t
|
||||
|
||||
struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 26 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 26 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
int32 m_nResultsReturned;
|
||||
int32 m_nTotalResultCount;
|
||||
@ -589,7 +585,7 @@ struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t
|
||||
|
||||
struct RemoteStorageSetUserPublishedFileActionResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 27 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 27 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
EWorkshopFileAction m_eAction; // the action that was attempted
|
||||
@ -597,7 +593,7 @@ struct RemoteStorageSetUserPublishedFileActionResult_t
|
||||
|
||||
struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 28 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 28 };
|
||||
EResult m_eResult; // The result of the operation.
|
||||
EWorkshopFileAction m_eAction; // the action that was filtered on
|
||||
int32 m_nResultsReturned;
|
||||
@ -612,7 +608,7 @@ struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishFileProgress_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 29 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 29 };
|
||||
double m_dPercentFile;
|
||||
bool m_bPreview;
|
||||
};
|
||||
@ -623,7 +619,7 @@ struct RemoteStoragePublishFileProgress_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStoragePublishedFileUpdated_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 30 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 30 };
|
||||
PublishedFileId_t m_nPublishedFileId; // The published file id
|
||||
AppId_t m_nAppID; // ID of the app that will consume this file.
|
||||
uint64 m_ulUnused; // not used anymore
|
||||
@ -634,7 +630,7 @@ struct RemoteStoragePublishedFileUpdated_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageFileWriteAsyncComplete_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 31 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 31 };
|
||||
EResult m_eResult; // result
|
||||
};
|
||||
|
||||
@ -643,7 +639,7 @@ struct RemoteStorageFileWriteAsyncComplete_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoteStorageFileReadAsyncComplete_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientRemoteStorageCallbacks + 32 };
|
||||
enum { k_iCallback = k_iSteamRemoteStorageCallbacks + 32 };
|
||||
SteamAPICall_t m_hFileReadAsync; // call handle of the async read which was made
|
||||
EResult m_eResult; // result
|
||||
uint32 m_nOffset; // offset in the file this read was at
|
||||
@ -655,7 +651,7 @@ struct RemoteStorageFileReadAsyncComplete_t
|
||||
// to remote session changes
|
||||
// Note: only posted if this happens DURING the local app session
|
||||
//-----------------------------------------------------------------------------
|
||||
STEAM_CALLBACK_BEGIN( RemoteStorageLocalFileChange_t, k_iClientRemoteStorageCallbacks + 33 )
|
||||
STEAM_CALLBACK_BEGIN( RemoteStorageLocalFileChange_t, k_iSteamRemoteStorageCallbacks + 33 )
|
||||
STEAM_CALLBACK_END( 0 )
|
||||
|
||||
#pragma pack( pop )
|
||||
|
||||
87
Generator/steam_sdk/isteamtv.h
Normal file
87
Generator/steam_sdk/isteamtv.h
Normal file
@ -0,0 +1,87 @@
|
||||
//====== Copyright © 1996-2014 Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose: interface to Steam Video
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef ISTEAMTV_H
|
||||
#define ISTEAMTV_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "steam_api_common.h"
|
||||
|
||||
// callbacks
|
||||
#if defined( VALVE_CALLBACK_PACK_SMALL )
|
||||
#pragma pack( push, 4 )
|
||||
#elif defined( VALVE_CALLBACK_PACK_LARGE )
|
||||
#pragma pack( push, 8 )
|
||||
#else
|
||||
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
|
||||
#endif
|
||||
|
||||
|
||||
enum { k_cchBroadcastGameDataMax = 8 * 1024 };
|
||||
|
||||
// What the interaction behavior of the region is
|
||||
enum ESteamTVRegionBehavior
|
||||
{
|
||||
k_ESteamVideoRegionBehaviorInvalid = -1,
|
||||
k_ESteamVideoRegionBehaviorHover = 0,
|
||||
k_ESteamVideoRegionBehaviorClickPopup = 1,
|
||||
k_ESteamVideoRegionBehaviorClickSurroundingRegion = 2,
|
||||
};
|
||||
|
||||
// Size of the region, normalized to 1920x1080
|
||||
struct SteamTVRegion_t
|
||||
{
|
||||
uint32 unMinX;
|
||||
uint32 unMinY;
|
||||
uint32 unMaxX;
|
||||
uint32 unMaxY;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: SteamTV API
|
||||
//-----------------------------------------------------------------------------
|
||||
class ISteamTV
|
||||
{
|
||||
public:
|
||||
|
||||
// Returns true if user is uploading a live broadcast
|
||||
virtual bool IsBroadcasting( int *pnNumViewers ) = 0;
|
||||
|
||||
// Broadcast game data
|
||||
virtual void AddBroadcastGameData( const char *pchKey, const char *pchValue ) = 0;
|
||||
virtual void RemoveBroadcastGameData( const char *pchKey ) = 0;
|
||||
|
||||
// Timeline marker
|
||||
virtual void AddTimelineMarker( const char *pchTemplateName, bool bPersistent, uint8 nColorR, uint8 nColorG, uint8 nColorB ) = 0;
|
||||
virtual void RemoveTimelineMarker() = 0;
|
||||
|
||||
// Regions
|
||||
virtual uint32 AddRegion( const char *pchElementName, const char *pchTimelineDataSection, const SteamTVRegion_t *pSteamTVRegion, ESteamTVRegionBehavior eSteamTVRegionBehavior ) = 0;
|
||||
virtual void RemoveRegion( uint32 unRegionHandle ) = 0;
|
||||
|
||||
// App Cheers
|
||||
virtual void SendAppCheer( uint64 unCheerTargetID, uint32 unCheerType, uint32 unCheerAmount ) = 0;
|
||||
};
|
||||
|
||||
#define STEAMTV_INTERFACE_VERSION "STEAMTV_INTERFACE_V002"
|
||||
|
||||
// Global interface accessor
|
||||
inline ISteamTV *SteamTV();
|
||||
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamTV *, SteamTV, STEAMTV_INTERFACE_VERSION );
|
||||
|
||||
STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iSteamVideoCallbacks + 4 )
|
||||
STEAM_CALLBACK_MEMBER( 0, bool, m_bIsRTMP )
|
||||
STEAM_CALLBACK_END(1)
|
||||
|
||||
STEAM_CALLBACK_BEGIN( BroadcastUploadStop_t, k_iSteamVideoCallbacks + 5 )
|
||||
STEAM_CALLBACK_MEMBER( 0, EBroadcastUploadResult, m_eResult )
|
||||
STEAM_CALLBACK_END(1)
|
||||
|
||||
#pragma pack( pop )
|
||||
|
||||
#endif // ISTEAMVIDEO_H
|
||||
@ -262,6 +262,8 @@ public:
|
||||
virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
|
||||
virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
|
||||
virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
|
||||
virtual bool SetTimeCreatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0;
|
||||
virtual bool SetTimeUpdatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0;
|
||||
virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0;
|
||||
|
||||
// DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!
|
||||
@ -369,7 +371,7 @@ public:
|
||||
virtual SteamAPICall_t GetWorkshopEULAStatus() = 0;
|
||||
};
|
||||
|
||||
#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION015"
|
||||
#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION016"
|
||||
|
||||
// Global interface accessor
|
||||
inline ISteamUGC *SteamUGC();
|
||||
@ -384,7 +386,7 @@ STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamUGC *, SteamGameServerUGC, STE
|
||||
//-----------------------------------------------------------------------------
|
||||
struct SteamUGCQueryCompleted_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 1 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 1 };
|
||||
UGCQueryHandle_t m_handle;
|
||||
EResult m_eResult;
|
||||
uint32 m_unNumResultsReturned;
|
||||
@ -399,7 +401,7 @@ struct SteamUGCQueryCompleted_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct SteamUGCRequestUGCDetailsResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 2 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 2 };
|
||||
SteamUGCDetails_t m_details;
|
||||
bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache
|
||||
};
|
||||
@ -410,7 +412,7 @@ struct SteamUGCRequestUGCDetailsResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct CreateItemResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 3 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 3 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId; // new item got this UGC PublishFileID
|
||||
bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
|
||||
@ -422,7 +424,7 @@ struct CreateItemResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct SubmitItemUpdateResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 4 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 4 };
|
||||
EResult m_eResult;
|
||||
bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
@ -434,7 +436,7 @@ struct SubmitItemUpdateResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct ItemInstalled_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 5 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 5 };
|
||||
AppId_t m_unAppID;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
};
|
||||
@ -445,7 +447,7 @@ struct ItemInstalled_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct DownloadItemResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 6 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 6 };
|
||||
AppId_t m_unAppID;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
EResult m_eResult;
|
||||
@ -456,7 +458,7 @@ struct DownloadItemResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct UserFavoriteItemsListChanged_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 7 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 7 };
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
EResult m_eResult;
|
||||
bool m_bWasAddRequest;
|
||||
@ -467,7 +469,7 @@ struct UserFavoriteItemsListChanged_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct SetUserItemVoteResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 8 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 8 };
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
EResult m_eResult;
|
||||
bool m_bVoteUp;
|
||||
@ -478,7 +480,7 @@ struct SetUserItemVoteResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct GetUserItemVoteResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 9 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 9 };
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
EResult m_eResult;
|
||||
bool m_bVotedUp;
|
||||
@ -491,7 +493,7 @@ struct GetUserItemVoteResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct StartPlaytimeTrackingResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 10 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 10 };
|
||||
EResult m_eResult;
|
||||
};
|
||||
|
||||
@ -500,7 +502,7 @@ struct StartPlaytimeTrackingResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct StopPlaytimeTrackingResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 11 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 11 };
|
||||
EResult m_eResult;
|
||||
};
|
||||
|
||||
@ -509,7 +511,7 @@ struct StopPlaytimeTrackingResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct AddUGCDependencyResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 12 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 12 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
PublishedFileId_t m_nChildPublishedFileId;
|
||||
@ -520,7 +522,7 @@ struct AddUGCDependencyResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoveUGCDependencyResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 13 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 13 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
PublishedFileId_t m_nChildPublishedFileId;
|
||||
@ -532,7 +534,7 @@ struct RemoveUGCDependencyResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct AddAppDependencyResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 14 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 14 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
AppId_t m_nAppID;
|
||||
@ -543,7 +545,7 @@ struct AddAppDependencyResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct RemoveAppDependencyResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 15 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 15 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
AppId_t m_nAppID;
|
||||
@ -555,7 +557,7 @@ struct RemoveAppDependencyResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct GetAppDependenciesResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 16 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 16 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
AppId_t m_rgAppIDs[32];
|
||||
@ -568,7 +570,7 @@ struct GetAppDependenciesResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct DeleteItemResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 17 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 17 };
|
||||
EResult m_eResult;
|
||||
PublishedFileId_t m_nPublishedFileId;
|
||||
};
|
||||
@ -579,7 +581,7 @@ struct DeleteItemResult_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct UserSubscribedItemsListChanged_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 18 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 18 };
|
||||
AppId_t m_nAppID;
|
||||
};
|
||||
|
||||
@ -589,7 +591,7 @@ struct UserSubscribedItemsListChanged_t
|
||||
//-----------------------------------------------------------------------------
|
||||
struct WorkshopEULAStatus_t
|
||||
{
|
||||
enum { k_iCallback = k_iClientUGCCallbacks + 20 };
|
||||
enum { k_iCallback = k_iSteamUGCCallbacks + 20 };
|
||||
EResult m_eResult;
|
||||
AppId_t m_nAppID;
|
||||
uint32 m_unVersion;
|
||||
|
||||
@ -221,6 +221,9 @@ public:
|
||||
|
||||
// In game launchers that don't have controller support you can call this to have Steam Input translate the controller input into mouse/kb to navigate the launcher
|
||||
virtual void SetGameLauncherMode( bool bLauncherMode ) = 0;
|
||||
|
||||
// Dismisses the floating keyboard.
|
||||
virtual bool DismissFloatingGamepadTextInput() = 0;
|
||||
};
|
||||
|
||||
#define STEAMUTILS_INTERFACE_VERSION "SteamUtils010"
|
||||
|
||||
@ -49,14 +49,14 @@ public:
|
||||
inline ISteamVideo *SteamVideo();
|
||||
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamVideo *, SteamVideo, STEAMVIDEO_INTERFACE_VERSION );
|
||||
|
||||
STEAM_CALLBACK_BEGIN( GetVideoURLResult_t, k_iClientVideoCallbacks + 11 )
|
||||
STEAM_CALLBACK_BEGIN( GetVideoURLResult_t, k_iSteamVideoCallbacks + 11 )
|
||||
STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult )
|
||||
STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID )
|
||||
STEAM_CALLBACK_MEMBER( 2, char, m_rgchURL[256] )
|
||||
STEAM_CALLBACK_END(3)
|
||||
|
||||
|
||||
STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iClientVideoCallbacks + 24 )
|
||||
STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iSteamVideoCallbacks + 24 )
|
||||
STEAM_CALLBACK_MEMBER( 0, EResult, m_eResult )
|
||||
STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID )
|
||||
STEAM_CALLBACK_END(2)
|
||||
|
||||
@ -339,7 +339,7 @@
|
||||
{
|
||||
"callback_id": 738,
|
||||
"fields": [],
|
||||
"struct": "ModalGamepadTextInputDismissed_t"
|
||||
"struct": "FloatingGamepadTextInputDismissed_t"
|
||||
},
|
||||
{
|
||||
"callback_id": 502,
|
||||
@ -1129,6 +1129,8 @@
|
||||
{ "fieldname":"m_hRequest", "fieldtype":"HTTPRequestHandle" },
|
||||
{ "fieldname":"m_ulContextValue", "fieldtype":"uint64" },
|
||||
{ "fieldname":"m_bRequestSuccessful", "fieldtype":"bool" },
|
||||
{ "fieldname":"m_TMP_bSuccessfulA", "fieldtype":"bool" },
|
||||
{ "fieldname":"m_TMP_bSuccessfulB", "fieldtype":"bool" },
|
||||
{ "fieldname":"m_eStatusCode", "fieldtype":"EHTTPStatusCode" },
|
||||
{ "fieldname":"m_unBodySize", "fieldtype":"uint32" }
|
||||
],
|
||||
@ -1825,6 +1827,19 @@
|
||||
{ "fieldname":"m_steamIDUser", "fieldtype":"CSteamID" }
|
||||
],
|
||||
"struct": "GSStatsUnloaded_t"
|
||||
},
|
||||
{
|
||||
"callback_id": 1223,
|
||||
"consts": [
|
||||
{ "constname":"k_nMaxReturnPorts", "consttype":"int", "constval":"8" }
|
||||
],
|
||||
"fields": [
|
||||
{ "fieldname":"m_eResult", "fieldtype":"EResult" },
|
||||
{ "fieldname":"m_identity", "fieldtype":"SteamNetworkingIdentity" },
|
||||
{ "fieldname":"m_unIP", "fieldtype":"uint32" },
|
||||
{ "fieldname":"m_unPorts", "fieldtype":"uint16 [8]" }
|
||||
],
|
||||
"struct": "SteamNetworkingFakeIPResult_t"
|
||||
}
|
||||
],
|
||||
"consts": [
|
||||
@ -1884,6 +1899,7 @@
|
||||
{ "constname":"k_cchMaxSteamNetworkingErrMsg", "consttype":"int", "constval":"1024" },
|
||||
{ "constname":"k_cchSteamNetworkingMaxConnectionCloseReason", "consttype":"int", "constval":"128" },
|
||||
{ "constname":"k_cchSteamNetworkingMaxConnectionDescription", "consttype":"int", "constval":"128" },
|
||||
{ "constname":"k_cchSteamNetworkingMaxConnectionAppName", "consttype":"int", "constval":"32" },
|
||||
{ "constname":"k_nSteamNetworkConnectionInfoFlags_Unauthenticated", "consttype":"int", "constval":"1" },
|
||||
{ "constname":"k_nSteamNetworkConnectionInfoFlags_Unencrypted", "consttype":"int", "constval":"2" },
|
||||
{ "constname":"k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers", "consttype":"int", "constval":"4" },
|
||||
@ -1914,7 +1930,9 @@
|
||||
{ "constname":"MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE", "consttype":"uint16", "constval":"STEAMGAMESERVER_QUERY_PORT_SHARED" },
|
||||
{ "constname":"k_cbSteamDatagramMaxSerializedTicket", "consttype":"uint32", "constval":"512" },
|
||||
{ "constname":"k_cbMaxSteamDatagramGameCoordinatorServerLoginAppData", "consttype":"uint32", "constval":"2048" },
|
||||
{ "constname":"k_cbMaxSteamDatagramGameCoordinatorServerLoginSerialized", "consttype":"uint32", "constval":"4096" }
|
||||
{ "constname":"k_cbMaxSteamDatagramGameCoordinatorServerLoginSerialized", "consttype":"uint32", "constval":"4096" },
|
||||
{ "constname":"k_cbSteamNetworkingSocketsFakeUDPPortRecommendedMTU", "consttype":"int", "constval":"1200" },
|
||||
{ "constname":"k_cbSteamNetworkingSocketsFakeUDPPortMaxMessageSize", "consttype":"int", "constval":"4096" }
|
||||
],
|
||||
"enums": [
|
||||
{
|
||||
@ -2059,7 +2077,8 @@
|
||||
{ "name":"k_EResultLauncherMigrated", "value":"119" },
|
||||
{ "name":"k_EResultSteamRealmMismatch", "value":"120" },
|
||||
{ "name":"k_EResultInvalidSignature", "value":"121" },
|
||||
{ "name":"k_EResultParseFailure", "value":"122" }
|
||||
{ "name":"k_EResultParseFailure", "value":"122" },
|
||||
{ "name":"k_EResultNoVerifiedPhone", "value":"123" }
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -2442,6 +2461,15 @@
|
||||
{ "name":"k_EGamepadTextInputLineModeMultipleLines", "value":"1" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"enumname": "EFloatingGamepadTextInputMode",
|
||||
"values": [
|
||||
{ "name":"k_EFloatingGamepadTextInputModeModeSingleLine", "value":"0" },
|
||||
{ "name":"k_EFloatingGamepadTextInputModeModeMultipleLines", "value":"1" },
|
||||
{ "name":"k_EFloatingGamepadTextInputModeModeEmail", "value":"2" },
|
||||
{ "name":"k_EFloatingGamepadTextInputModeModeNumeric", "value":"3" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"enumname": "ETextFilteringContext",
|
||||
"values": [
|
||||
@ -3161,7 +3189,80 @@
|
||||
{ "name":"k_EInputActionOrigin_PS5_Reserved18", "value":"330" },
|
||||
{ "name":"k_EInputActionOrigin_PS5_Reserved19", "value":"331" },
|
||||
{ "name":"k_EInputActionOrigin_PS5_Reserved20", "value":"332" },
|
||||
{ "name":"k_EInputActionOrigin_Count", "value":"333" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_A", "value":"333" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_B", "value":"334" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_X", "value":"335" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Y", "value":"336" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L1", "value":"337" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R1", "value":"338" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Menu", "value":"339" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_View", "value":"340" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_Touch", "value":"341" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_Swipe", "value":"342" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_Click", "value":"343" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_DPadNorth", "value":"344" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_DPadSouth", "value":"345" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_DPadWest", "value":"346" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftPad_DPadEast", "value":"347" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_Touch", "value":"348" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_Swipe", "value":"349" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_Click", "value":"350" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_DPadNorth", "value":"351" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_DPadSouth", "value":"352" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_DPadWest", "value":"353" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightPad_DPadEast", "value":"354" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L2_SoftPull", "value":"355" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L2", "value":"356" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R2_SoftPull", "value":"357" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R2", "value":"358" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_Move", "value":"359" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L3", "value":"360" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_DPadNorth", "value":"361" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_DPadSouth", "value":"362" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_DPadWest", "value":"363" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_DPadEast", "value":"364" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_LeftStick_Touch", "value":"365" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_Move", "value":"366" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R3", "value":"367" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_DPadNorth", "value":"368" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_DPadSouth", "value":"369" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_DPadWest", "value":"370" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_DPadEast", "value":"371" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_RightStick_Touch", "value":"372" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L4", "value":"373" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R4", "value":"374" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_L5", "value":"375" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_R5", "value":"376" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_DPad_Move", "value":"377" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_DPad_North", "value":"378" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_DPad_South", "value":"379" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_DPad_West", "value":"380" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_DPad_East", "value":"381" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Gyro_Move", "value":"382" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Gyro_Pitch", "value":"383" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Gyro_Yaw", "value":"384" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Gyro_Roll", "value":"385" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved1", "value":"386" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved2", "value":"387" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved3", "value":"388" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved4", "value":"389" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved5", "value":"390" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved6", "value":"391" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved7", "value":"392" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved8", "value":"393" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved9", "value":"394" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved10", "value":"395" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved11", "value":"396" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved12", "value":"397" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved13", "value":"398" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved14", "value":"399" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved15", "value":"400" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved16", "value":"401" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved17", "value":"402" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved18", "value":"403" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved19", "value":"404" },
|
||||
{ "name":"k_EInputActionOrigin_SteamDeck_Reserved20", "value":"405" },
|
||||
{ "name":"k_EInputActionOrigin_Count", "value":"406" },
|
||||
{ "name":"k_EInputActionOrigin_MaximumPossibleValue", "value":"32767" }
|
||||
]
|
||||
},
|
||||
@ -3265,7 +3366,18 @@
|
||||
"values": [
|
||||
{ "name":"k_ESteamInputGlyphSize_Small", "value":"0" },
|
||||
{ "name":"k_ESteamInputGlyphSize_Medium", "value":"1" },
|
||||
{ "name":"k_ESteamInputGlyphSize_Large", "value":"2" }
|
||||
{ "name":"k_ESteamInputGlyphSize_Large", "value":"2" },
|
||||
{ "name":"k_ESteamInputGlyphSize_Count", "value":"3" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"enumname": "ESteamInputGlyphStyle",
|
||||
"values": [
|
||||
{ "name":"ESteamInputGlyphStyle_Standard", "value":"0" },
|
||||
{ "name":"ESteamInputGlyphStyle_Light", "value":"1" },
|
||||
{ "name":"ESteamInputGlyphStyle_Dark", "value":"2" },
|
||||
{ "name":"ESteamInputGlyphStyle_NeutralColorABXY", "value":"16" },
|
||||
{ "name":"ESteamInputGlyphStyle_OutlineOnlyABXY", "value":"32" }
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -3583,7 +3695,80 @@
|
||||
{ "name":"k_EControllerActionOrigin_XBoxOne_RightGrip_Lower", "value":"302" },
|
||||
{ "name":"k_EControllerActionOrigin_XBoxOne_RightGrip_Upper", "value":"303" },
|
||||
{ "name":"k_EControllerActionOrigin_XBoxOne_Share", "value":"304" },
|
||||
{ "name":"k_EControllerActionOrigin_Count", "value":"305" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_A", "value":"305" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_B", "value":"306" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_X", "value":"307" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Y", "value":"308" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L1", "value":"309" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R1", "value":"310" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Menu", "value":"311" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_View", "value":"312" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_Touch", "value":"313" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_Swipe", "value":"314" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_Click", "value":"315" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_DPadNorth", "value":"316" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_DPadSouth", "value":"317" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_DPadWest", "value":"318" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftPad_DPadEast", "value":"319" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_Touch", "value":"320" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_Swipe", "value":"321" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_Click", "value":"322" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_DPadNorth", "value":"323" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_DPadSouth", "value":"324" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_DPadWest", "value":"325" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightPad_DPadEast", "value":"326" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L2_SoftPull", "value":"327" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L2", "value":"328" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R2_SoftPull", "value":"329" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R2", "value":"330" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_Move", "value":"331" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L3", "value":"332" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_DPadNorth", "value":"333" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_DPadSouth", "value":"334" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_DPadWest", "value":"335" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_DPadEast", "value":"336" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_LeftStick_Touch", "value":"337" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_Move", "value":"338" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R3", "value":"339" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_DPadNorth", "value":"340" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_DPadSouth", "value":"341" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_DPadWest", "value":"342" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_DPadEast", "value":"343" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_RightStick_Touch", "value":"344" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L4", "value":"345" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R4", "value":"346" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_L5", "value":"347" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_R5", "value":"348" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_DPad_Move", "value":"349" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_DPad_North", "value":"350" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_DPad_South", "value":"351" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_DPad_West", "value":"352" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_DPad_East", "value":"353" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Gyro_Move", "value":"354" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Gyro_Pitch", "value":"355" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Gyro_Yaw", "value":"356" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Gyro_Roll", "value":"357" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved1", "value":"358" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved2", "value":"359" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved3", "value":"360" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved4", "value":"361" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved5", "value":"362" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved6", "value":"363" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved7", "value":"364" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved8", "value":"365" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved9", "value":"366" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved10", "value":"367" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved11", "value":"368" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved12", "value":"369" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved13", "value":"370" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved14", "value":"371" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved15", "value":"372" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved16", "value":"373" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved17", "value":"374" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved18", "value":"375" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved19", "value":"376" },
|
||||
{ "name":"k_EControllerActionOrigin_SteamDeck_Reserved20", "value":"377" },
|
||||
{ "name":"k_EControllerActionOrigin_Count", "value":"378" },
|
||||
{ "name":"k_EControllerActionOrigin_MaximumPossibleValue", "value":"32767" }
|
||||
]
|
||||
},
|
||||
@ -3876,6 +4061,7 @@
|
||||
{ "name":"k_ESteamNetworkingConfig_SymmetricConnect", "value":"37" },
|
||||
{ "name":"k_ESteamNetworkingConfig_LocalVirtualPort", "value":"38" },
|
||||
{ "name":"k_ESteamNetworkingConfig_DualWifi_Enable", "value":"39" },
|
||||
{ "name":"k_ESteamNetworkingConfig_EnableDiagnosticsUI", "value":"46" },
|
||||
{ "name":"k_ESteamNetworkingConfig_FakePacketLoss_Send", "value":"2" },
|
||||
{ "name":"k_ESteamNetworkingConfig_FakePacketLoss_Recv", "value":"3" },
|
||||
{ "name":"k_ESteamNetworkingConfig_FakePacketLag_Send", "value":"4" },
|
||||
@ -5518,10 +5704,14 @@
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "ShowModalGamepadTextInput",
|
||||
"methodname_flat": "SteamAPI_ISteamUtils_ShowModalGamepadTextInput",
|
||||
"methodname": "ShowFloatingGamepadTextInput",
|
||||
"methodname_flat": "SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput",
|
||||
"params": [
|
||||
{ "paramname":"eLineInputMode", "paramtype":"EGamepadTextInputLineMode" }
|
||||
{ "paramname":"eKeyboardMode", "paramtype":"EFloatingGamepadTextInputMode" },
|
||||
{ "paramname":"nTextFieldXPosition", "paramtype":"int" },
|
||||
{ "paramname":"nTextFieldYPosition", "paramtype":"int" },
|
||||
{ "paramname":"nTextFieldWidth", "paramtype":"int" },
|
||||
{ "paramname":"nTextFieldHeight", "paramtype":"int" }
|
||||
],
|
||||
"returntype": "bool"
|
||||
},
|
||||
@ -5532,6 +5722,12 @@
|
||||
{ "paramname":"bLauncherMode", "paramtype":"bool" }
|
||||
],
|
||||
"returntype": "void"
|
||||
},
|
||||
{
|
||||
"methodname": "DismissFloatingGamepadTextInput",
|
||||
"methodname_flat": "SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput",
|
||||
"params": [],
|
||||
"returntype": "bool"
|
||||
}
|
||||
],
|
||||
"version_string": "SteamUtils010"
|
||||
@ -9419,12 +9615,12 @@
|
||||
{
|
||||
"kind": "user",
|
||||
"name": "SteamUGC",
|
||||
"name_flat": "SteamAPI_SteamUGC_v015"
|
||||
"name_flat": "SteamAPI_SteamUGC_v016"
|
||||
},
|
||||
{
|
||||
"kind": "gameserver",
|
||||
"name": "SteamGameServerUGC",
|
||||
"name_flat": "SteamAPI_SteamGameServerUGC_v015"
|
||||
"name_flat": "SteamAPI_SteamGameServerUGC_v016"
|
||||
}
|
||||
],
|
||||
"classname": "ISteamUGC",
|
||||
@ -9829,6 +10025,26 @@
|
||||
],
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "SetTimeCreatedDateRange",
|
||||
"methodname_flat": "SteamAPI_ISteamUGC_SetTimeCreatedDateRange",
|
||||
"params": [
|
||||
{ "paramname":"handle", "paramtype":"UGCQueryHandle_t" },
|
||||
{ "paramname":"rtStart", "paramtype":"RTime32" },
|
||||
{ "paramname":"rtEnd", "paramtype":"RTime32" }
|
||||
],
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "SetTimeUpdatedDateRange",
|
||||
"methodname_flat": "SteamAPI_ISteamUGC_SetTimeUpdatedDateRange",
|
||||
"params": [
|
||||
{ "paramname":"handle", "paramtype":"UGCQueryHandle_t" },
|
||||
{ "paramname":"rtStart", "paramtype":"RTime32" },
|
||||
{ "paramname":"rtEnd", "paramtype":"RTime32" }
|
||||
],
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "AddRequiredKeyValueTag",
|
||||
"methodname_flat": "SteamAPI_ISteamUGC_AddRequiredKeyValueTag",
|
||||
@ -10275,7 +10491,7 @@
|
||||
"returntype": "SteamAPICall_t"
|
||||
}
|
||||
],
|
||||
"version_string": "STEAMUGC_INTERFACE_VERSION015"
|
||||
"version_string": "STEAMUGC_INTERFACE_VERSION016"
|
||||
},
|
||||
{
|
||||
"accessors": [
|
||||
@ -11501,7 +11717,7 @@
|
||||
"params": [
|
||||
{ "paramname":"identityRemote", "paramtype":"const SteamNetworkingIdentity &" },
|
||||
{ "paramname":"pConnectionInfo", "paramtype":"SteamNetConnectionInfo_t *" },
|
||||
{ "paramname":"pQuickStatus", "paramtype":"SteamNetworkingQuickConnectionStatus *" }
|
||||
{ "paramname":"pQuickStatus", "paramtype":"SteamNetConnectionRealTimeStatus_t *" }
|
||||
],
|
||||
"returntype": "ESteamNetworkingConnectionState"
|
||||
}
|
||||
@ -11513,12 +11729,12 @@
|
||||
{
|
||||
"kind": "user",
|
||||
"name": "SteamNetworkingSockets_SteamAPI",
|
||||
"name_flat": "SteamAPI_SteamNetworkingSockets_SteamAPI_v011"
|
||||
"name_flat": "SteamAPI_SteamNetworkingSockets_SteamAPI_v012"
|
||||
},
|
||||
{
|
||||
"kind": "gameserver",
|
||||
"name": "SteamGameServerNetworkingSockets_SteamAPI",
|
||||
"name_flat": "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011"
|
||||
"name_flat": "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012"
|
||||
}
|
||||
],
|
||||
"classname": "ISteamNetworkingSockets",
|
||||
@ -11678,13 +11894,15 @@
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "GetQuickConnectionStatus",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus",
|
||||
"methodname": "GetConnectionRealTimeStatus",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus",
|
||||
"params": [
|
||||
{ "paramname":"hConn", "paramtype":"HSteamNetConnection" },
|
||||
{ "paramname":"pStats", "paramtype":"SteamNetworkingQuickConnectionStatus *" }
|
||||
{ "paramname":"pStatus", "paramtype":"SteamNetConnectionRealTimeStatus_t *" },
|
||||
{ "paramname":"nLanes", "paramtype":"int" },
|
||||
{ "paramname":"pLanes", "paramtype":"SteamNetConnectionRealTimeLaneStatus_t *" }
|
||||
],
|
||||
"returntype": "bool"
|
||||
"returntype": "EResult"
|
||||
},
|
||||
{
|
||||
"methodname": "GetDetailedConnectionStatus",
|
||||
@ -11717,6 +11935,17 @@
|
||||
],
|
||||
"returntype": "bool"
|
||||
},
|
||||
{
|
||||
"methodname": "ConfigureConnectionLanes",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes",
|
||||
"params": [
|
||||
{ "paramname":"hConn", "paramtype":"HSteamNetConnection" },
|
||||
{ "paramname":"nNumLanes", "paramtype":"int" },
|
||||
{ "paramname":"pLanePriorities", "paramtype":"const int *" },
|
||||
{ "paramname":"pLaneWeights", "paramtype":"const uint16 *" }
|
||||
],
|
||||
"returntype": "EResult"
|
||||
},
|
||||
{
|
||||
"methodname": "GetIdentity",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_GetIdentity",
|
||||
@ -11898,9 +12127,17 @@
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_RunCallbacks",
|
||||
"params": [],
|
||||
"returntype": "void"
|
||||
},
|
||||
{
|
||||
"methodname": "CreateFakeUDPPort",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort",
|
||||
"params": [
|
||||
{ "paramname":"idxFakeServerPort", "paramtype":"int" }
|
||||
],
|
||||
"returntype": "ISteamNetworkingFakeUDPPort *"
|
||||
}
|
||||
],
|
||||
"version_string": "SteamNetworkingSockets011"
|
||||
"version_string": "SteamNetworkingSockets012"
|
||||
},
|
||||
{
|
||||
"accessors": [
|
||||
@ -12689,6 +12926,46 @@
|
||||
}
|
||||
],
|
||||
"version_string": "SteamGameServerStats001"
|
||||
},
|
||||
{
|
||||
"classname": "ISteamNetworkingFakeUDPPort",
|
||||
"fields": [],
|
||||
"methods": [
|
||||
{
|
||||
"methodname": "DestroyFakeUDPPort",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort",
|
||||
"params": [],
|
||||
"returntype": "void"
|
||||
},
|
||||
{
|
||||
"methodname": "SendMessageToFakeIP",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP",
|
||||
"params": [
|
||||
{ "paramname":"remoteAddress", "paramtype":"const SteamNetworkingIPAddr &" },
|
||||
{ "paramname":"pData", "paramtype":"const void *" },
|
||||
{ "paramname":"cbData", "paramtype":"uint32" },
|
||||
{ "paramname":"nSendFlags", "paramtype":"int" }
|
||||
],
|
||||
"returntype": "EResult"
|
||||
},
|
||||
{
|
||||
"methodname": "ReceiveMessages",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages",
|
||||
"params": [
|
||||
{ "paramname":"ppOutMessages", "paramtype":"SteamNetworkingMessage_t **" },
|
||||
{ "paramname":"nMaxMessages", "paramtype":"int" }
|
||||
],
|
||||
"returntype": "int"
|
||||
},
|
||||
{
|
||||
"methodname": "ScheduleCleanup",
|
||||
"methodname_flat": "SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup",
|
||||
"params": [
|
||||
{ "paramname":"remoteAddress", "paramtype":"const SteamNetworkingIPAddr &" }
|
||||
],
|
||||
"returntype": "void"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"structs": [
|
||||
@ -12961,8 +13238,7 @@
|
||||
"fields": [
|
||||
{ "fieldname":"controllerHandle", "fieldtype":"InputHandle_t" },
|
||||
{ "fieldname":"eEventType", "fieldtype":"ESteamInputActionEventType" },
|
||||
{ "fieldname":"analogAction_actionHandle", "fieldtype":"InputAnalogActionHandle_t" },
|
||||
{ "fieldname":"analogAction_analogActionData", "fieldtype":"InputAnalogActionData_t" }
|
||||
{ "fieldname":"analogAction", "fieldtype":"SteamInputActionEvent_t::AnalogAction_t" }
|
||||
],
|
||||
"struct": "SteamInputActionEvent_t"
|
||||
},
|
||||
@ -13331,7 +13607,18 @@
|
||||
{ "fieldname":"m_usecQueueTime", "fieldtype":"SteamNetworkingMicroseconds" },
|
||||
{ "fieldname":"reserved", "fieldtype":"uint32 [16]" }
|
||||
],
|
||||
"struct": "SteamNetworkingQuickConnectionStatus"
|
||||
"struct": "SteamNetConnectionRealTimeStatus_t"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
{ "fieldname":"m_cbPendingUnreliable", "fieldtype":"int" },
|
||||
{ "fieldname":"m_cbPendingReliable", "fieldtype":"int" },
|
||||
{ "fieldname":"m_cbSentUnackedReliable", "fieldtype":"int" },
|
||||
{ "fieldname":"_reservePad1", "fieldtype":"int" },
|
||||
{ "fieldname":"m_usecQueueTime", "fieldtype":"SteamNetworkingMicroseconds" },
|
||||
{ "fieldname":"reserved", "fieldtype":"uint32 [10]" }
|
||||
],
|
||||
"struct": "SteamNetConnectionRealTimeLaneStatus_t"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
@ -13346,7 +13633,9 @@
|
||||
{ "fieldname":"m_pfnRelease", "fieldtype":"void (*)(SteamNetworkingMessage_t *)" },
|
||||
{ "fieldname":"m_nChannel", "fieldtype":"int" },
|
||||
{ "fieldname":"m_nFlags", "fieldtype":"int" },
|
||||
{ "fieldname":"m_nUserData", "fieldtype":"int64" }
|
||||
{ "fieldname":"m_nUserData", "fieldtype":"int64" },
|
||||
{ "fieldname":"m_idxLane", "fieldtype":"uint16" },
|
||||
{ "fieldname":"_pad1__", "fieldtype":"uint16" }
|
||||
],
|
||||
"methods": [
|
||||
{
|
||||
@ -13419,60 +13708,6 @@
|
||||
],
|
||||
"struct": "SteamNetworkingConfigValue_t"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "buf",
|
||||
"fieldtype": "char [8]",
|
||||
"private": true
|
||||
}
|
||||
],
|
||||
"methods": [
|
||||
{
|
||||
"methodname": "c_str",
|
||||
"methodname_flat": "SteamAPI_SteamNetworkingPOPIDRender_c_str",
|
||||
"params": [],
|
||||
"returntype": "const char *"
|
||||
}
|
||||
],
|
||||
"struct": "SteamNetworkingPOPIDRender"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "buf",
|
||||
"fieldtype": "char [128]",
|
||||
"private": true
|
||||
}
|
||||
],
|
||||
"methods": [
|
||||
{
|
||||
"methodname": "c_str",
|
||||
"methodname_flat": "SteamAPI_SteamNetworkingIdentityRender_c_str",
|
||||
"params": [],
|
||||
"returntype": "const char *"
|
||||
}
|
||||
],
|
||||
"struct": "SteamNetworkingIdentityRender"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
{
|
||||
"fieldname": "buf",
|
||||
"fieldtype": "char [48]",
|
||||
"private": true
|
||||
}
|
||||
],
|
||||
"methods": [
|
||||
{
|
||||
"methodname": "c_str",
|
||||
"methodname_flat": "SteamAPI_SteamNetworkingIPAddrRender_c_str",
|
||||
"params": [],
|
||||
"returntype": "const char *"
|
||||
}
|
||||
],
|
||||
"struct": "SteamNetworkingIPAddrRender"
|
||||
},
|
||||
{
|
||||
"fields": [
|
||||
{ "fieldname":"m_cbSize", "fieldtype":"int" },
|
||||
|
||||
@ -56,7 +56,11 @@ S_API ISteamParties * SteamAPI_ISteamClient_GetISteamParties( ISteamClient* self
|
||||
S_API ISteamRemotePlay * SteamAPI_ISteamClient_GetISteamRemotePlay( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion );
|
||||
|
||||
// ISteamUser
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUser *SteamAPI_SteamUser_v021();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamUser(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUser *SteamAPI_SteamUser() { return SteamAPI_SteamUser_v021(); }
|
||||
S_API HSteamUser SteamAPI_ISteamUser_GetHSteamUser( ISteamUser* self );
|
||||
S_API bool SteamAPI_ISteamUser_BLoggedOn( ISteamUser* self );
|
||||
S_API uint64_steamid SteamAPI_ISteamUser_GetSteamID( ISteamUser* self );
|
||||
@ -91,7 +95,11 @@ S_API SteamAPICall_t SteamAPI_ISteamUser_GetDurationControl( ISteamUser* self );
|
||||
S_API bool SteamAPI_ISteamUser_BSetDurationControlOnlineState( ISteamUser* self, EDurationControlOnlineState eNewState );
|
||||
|
||||
// ISteamFriends
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamFriends *SteamAPI_SteamFriends_v017();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamFriends(), but using this ensures that you are using a matching library.
|
||||
inline ISteamFriends *SteamAPI_SteamFriends() { return SteamAPI_SteamFriends_v017(); }
|
||||
S_API const char * SteamAPI_ISteamFriends_GetPersonaName( ISteamFriends* self );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamFriends_SetPersonaName( ISteamFriends* self, const char * pchPersonaName );
|
||||
S_API EPersonaState SteamAPI_ISteamFriends_GetPersonaState( ISteamFriends* self );
|
||||
@ -170,8 +178,16 @@ S_API bool SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser( ISteamFriend
|
||||
S_API void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString( ISteamFriends* self, const char * pchConnectString );
|
||||
|
||||
// ISteamUtils
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUtils *SteamAPI_SteamUtils_v010();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamUtils(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUtils *SteamAPI_SteamUtils() { return SteamAPI_SteamUtils_v010(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUtils *SteamAPI_SteamGameServerUtils_v010();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerUtils(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUtils *SteamAPI_SteamGameServerUtils() { return SteamAPI_SteamGameServerUtils_v010(); }
|
||||
S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceAppActive( ISteamUtils* self );
|
||||
S_API uint32 SteamAPI_ISteamUtils_GetSecondsSinceComputerActive( ISteamUtils* self );
|
||||
S_API EUniverse SteamAPI_ISteamUtils_GetConnectedUniverse( ISteamUtils* self );
|
||||
@ -205,11 +221,16 @@ S_API bool SteamAPI_ISteamUtils_InitFilterText( ISteamUtils* self, uint32 unFilt
|
||||
S_API int SteamAPI_ISteamUtils_FilterText( ISteamUtils* self, ETextFilteringContext eContext, uint64_steamid sourceSteamID, const char * pchInputMessage, char * pchOutFilteredText, uint32 nByteSizeOutFilteredText );
|
||||
S_API ESteamIPv6ConnectivityState SteamAPI_ISteamUtils_GetIPv6ConnectivityState( ISteamUtils* self, ESteamIPv6ConnectivityProtocol eProtocol );
|
||||
S_API bool SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck( ISteamUtils* self );
|
||||
S_API bool SteamAPI_ISteamUtils_ShowModalGamepadTextInput( ISteamUtils* self, EGamepadTextInputLineMode eLineInputMode );
|
||||
S_API bool SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput( ISteamUtils* self, EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight );
|
||||
S_API void SteamAPI_ISteamUtils_SetGameLauncherMode( ISteamUtils* self, bool bLauncherMode );
|
||||
S_API bool SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput( ISteamUtils* self );
|
||||
|
||||
// ISteamMatchmaking
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamMatchmaking *SteamAPI_SteamMatchmaking_v009();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamMatchmaking(), but using this ensures that you are using a matching library.
|
||||
inline ISteamMatchmaking *SteamAPI_SteamMatchmaking() { return SteamAPI_SteamMatchmaking_v009(); }
|
||||
S_API int SteamAPI_ISteamMatchmaking_GetFavoriteGameCount( ISteamMatchmaking* self );
|
||||
S_API bool SteamAPI_ISteamMatchmaking_GetFavoriteGame( ISteamMatchmaking* self, int iGame, AppId_t * pnAppID, uint32 * pnIP, uint16 * pnConnPort, uint16 * pnQueryPort, uint32 * punFlags, uint32 * pRTime32LastPlayedOnServer );
|
||||
S_API int SteamAPI_ISteamMatchmaking_AddFavoriteGame( ISteamMatchmaking* self, AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer );
|
||||
@ -269,7 +290,11 @@ S_API void SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond( ISteamM
|
||||
S_API void SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete( ISteamMatchmakingRulesResponse* self );
|
||||
|
||||
// ISteamMatchmakingServers
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamMatchmakingServers *SteamAPI_SteamMatchmakingServers_v002();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamMatchmakingServers(), but using this ensures that you are using a matching library.
|
||||
inline ISteamMatchmakingServers *SteamAPI_SteamMatchmakingServers() { return SteamAPI_SteamMatchmakingServers_v002(); }
|
||||
S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestInternetServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse );
|
||||
S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestLANServerList( ISteamMatchmakingServers* self, AppId_t iApp, ISteamMatchmakingServerListResponse * pRequestServersResponse );
|
||||
S_API HServerListRequest SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList( ISteamMatchmakingServers* self, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse );
|
||||
@ -289,7 +314,11 @@ S_API HServerQuery SteamAPI_ISteamMatchmakingServers_ServerRules( ISteamMatchmak
|
||||
S_API void SteamAPI_ISteamMatchmakingServers_CancelServerQuery( ISteamMatchmakingServers* self, HServerQuery hServerQuery );
|
||||
|
||||
// ISteamGameSearch
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamGameSearch *SteamAPI_SteamGameSearch_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameSearch(), but using this ensures that you are using a matching library.
|
||||
inline ISteamGameSearch *SteamAPI_SteamGameSearch() { return SteamAPI_SteamGameSearch_v001(); }
|
||||
S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_AddGameSearchParams( ISteamGameSearch* self, const char * pchKeyToFind, const char * pchValuesToFind );
|
||||
S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SearchForGameWithLobby( ISteamGameSearch* self, uint64_steamid steamIDLobby, int nPlayerMin, int nPlayerMax );
|
||||
S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SearchForGameSolo( ISteamGameSearch* self, int nPlayerMin, int nPlayerMax );
|
||||
@ -306,7 +335,11 @@ S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_SubmitPlayerResult( IStea
|
||||
S_API EGameSearchErrorCode_t SteamAPI_ISteamGameSearch_EndGame( ISteamGameSearch* self, uint64 ullUniqueGameID );
|
||||
|
||||
// ISteamParties
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamParties *SteamAPI_SteamParties_v002();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamParties(), but using this ensures that you are using a matching library.
|
||||
inline ISteamParties *SteamAPI_SteamParties() { return SteamAPI_SteamParties_v002(); }
|
||||
S_API uint32 SteamAPI_ISteamParties_GetNumActiveBeacons( ISteamParties* self );
|
||||
S_API PartyBeaconID_t SteamAPI_ISteamParties_GetBeaconByIndex( ISteamParties* self, uint32 unIndex );
|
||||
S_API bool SteamAPI_ISteamParties_GetBeaconDetails( ISteamParties* self, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, SteamPartyBeaconLocation_t * pLocation, char * pchMetadata, int cchMetadata );
|
||||
@ -321,7 +354,11 @@ S_API bool SteamAPI_ISteamParties_DestroyBeacon( ISteamParties* self, PartyBeaco
|
||||
S_API bool SteamAPI_ISteamParties_GetBeaconLocationData( ISteamParties* self, SteamPartyBeaconLocation_t BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut );
|
||||
|
||||
// ISteamRemoteStorage
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamRemoteStorage *SteamAPI_SteamRemoteStorage_v016();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamRemoteStorage(), but using this ensures that you are using a matching library.
|
||||
inline ISteamRemoteStorage *SteamAPI_SteamRemoteStorage() { return SteamAPI_SteamRemoteStorage_v016(); }
|
||||
S_API bool SteamAPI_ISteamRemoteStorage_FileWrite( ISteamRemoteStorage* self, const char * pchFile, const void * pvData, int32 cubData );
|
||||
S_API int32 SteamAPI_ISteamRemoteStorage_FileRead( ISteamRemoteStorage* self, const char * pchFile, void * pvData, int32 cubDataToRead );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileWriteAsync( ISteamRemoteStorage* self, const char * pchFile, const void * pvData, uint32 cubData );
|
||||
@ -383,7 +420,11 @@ S_API bool SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch( ISteamRemoteStorage
|
||||
S_API bool SteamAPI_ISteamRemoteStorage_EndFileWriteBatch( ISteamRemoteStorage* self );
|
||||
|
||||
// ISteamUserStats
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUserStats *SteamAPI_SteamUserStats_v012();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamUserStats(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUserStats *SteamAPI_SteamUserStats() { return SteamAPI_SteamUserStats_v012(); }
|
||||
S_API bool SteamAPI_ISteamUserStats_RequestCurrentStats( ISteamUserStats* self );
|
||||
S_API bool SteamAPI_ISteamUserStats_GetStatInt32( ISteamUserStats* self, const char * pchName, int32 * pData );
|
||||
S_API bool SteamAPI_ISteamUserStats_GetStatFloat( ISteamUserStats* self, const char * pchName, float * pData );
|
||||
@ -431,7 +472,11 @@ S_API bool SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32( ISteamUse
|
||||
S_API bool SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat( ISteamUserStats* self, const char * pchName, float * pfMinProgress, float * pfMaxProgress );
|
||||
|
||||
// ISteamApps
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamApps *SteamAPI_SteamApps_v008();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamApps(), but using this ensures that you are using a matching library.
|
||||
inline ISteamApps *SteamAPI_SteamApps() { return SteamAPI_SteamApps_v008(); }
|
||||
S_API bool SteamAPI_ISteamApps_BIsSubscribed( ISteamApps* self );
|
||||
S_API bool SteamAPI_ISteamApps_BIsLowViolence( ISteamApps* self );
|
||||
S_API bool SteamAPI_ISteamApps_BIsCybercafe( ISteamApps* self );
|
||||
@ -463,8 +508,16 @@ S_API bool SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing( ISteamApps* self
|
||||
S_API bool SteamAPI_ISteamApps_BIsTimedTrial( ISteamApps* self, uint32 * punSecondsAllowed, uint32 * punSecondsPlayed );
|
||||
|
||||
// ISteamNetworking
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworking *SteamAPI_SteamNetworking_v006();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworking(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworking *SteamAPI_SteamNetworking() { return SteamAPI_SteamNetworking_v006(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworking *SteamAPI_SteamGameServerNetworking_v006();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworking(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworking *SteamAPI_SteamGameServerNetworking() { return SteamAPI_SteamGameServerNetworking_v006(); }
|
||||
S_API bool SteamAPI_ISteamNetworking_SendP2PPacket( ISteamNetworking* self, uint64_steamid steamIDRemote, const void * pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel );
|
||||
S_API bool SteamAPI_ISteamNetworking_IsP2PPacketAvailable( ISteamNetworking* self, uint32 * pcubMsgSize, int nChannel );
|
||||
S_API bool SteamAPI_ISteamNetworking_ReadP2PPacket( ISteamNetworking* self, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, CSteamID * psteamIDRemote, int nChannel );
|
||||
@ -489,7 +542,11 @@ S_API ESNetSocketConnectionType SteamAPI_ISteamNetworking_GetSocketConnectionTyp
|
||||
S_API int SteamAPI_ISteamNetworking_GetMaxPacketSize( ISteamNetworking* self, SNetSocket_t hSocket );
|
||||
|
||||
// ISteamScreenshots
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamScreenshots *SteamAPI_SteamScreenshots_v003();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamScreenshots(), but using this ensures that you are using a matching library.
|
||||
inline ISteamScreenshots *SteamAPI_SteamScreenshots() { return SteamAPI_SteamScreenshots_v003(); }
|
||||
S_API ScreenshotHandle SteamAPI_ISteamScreenshots_WriteScreenshot( ISteamScreenshots* self, void * pubRGB, uint32 cubRGB, int nWidth, int nHeight );
|
||||
S_API ScreenshotHandle SteamAPI_ISteamScreenshots_AddScreenshotToLibrary( ISteamScreenshots* self, const char * pchFilename, const char * pchThumbnailFilename, int nWidth, int nHeight );
|
||||
S_API void SteamAPI_ISteamScreenshots_TriggerScreenshot( ISteamScreenshots* self );
|
||||
@ -501,7 +558,11 @@ S_API bool SteamAPI_ISteamScreenshots_IsScreenshotsHooked( ISteamScreenshots* se
|
||||
S_API ScreenshotHandle SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary( ISteamScreenshots* self, EVRScreenshotType eType, const char * pchFilename, const char * pchVRFilename );
|
||||
|
||||
// ISteamMusic
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamMusic *SteamAPI_SteamMusic_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamMusic(), but using this ensures that you are using a matching library.
|
||||
inline ISteamMusic *SteamAPI_SteamMusic() { return SteamAPI_SteamMusic_v001(); }
|
||||
S_API bool SteamAPI_ISteamMusic_BIsEnabled( ISteamMusic* self );
|
||||
S_API bool SteamAPI_ISteamMusic_BIsPlaying( ISteamMusic* self );
|
||||
S_API AudioPlayback_Status SteamAPI_ISteamMusic_GetPlaybackStatus( ISteamMusic* self );
|
||||
@ -513,7 +574,11 @@ S_API void SteamAPI_ISteamMusic_SetVolume( ISteamMusic* self, float flVolume );
|
||||
S_API float SteamAPI_ISteamMusic_GetVolume( ISteamMusic* self );
|
||||
|
||||
// ISteamMusicRemote
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamMusicRemote *SteamAPI_SteamMusicRemote_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamMusicRemote(), but using this ensures that you are using a matching library.
|
||||
inline ISteamMusicRemote *SteamAPI_SteamMusicRemote() { return SteamAPI_SteamMusicRemote_v001(); }
|
||||
S_API bool SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote( ISteamMusicRemote* self, const char * pchName );
|
||||
S_API bool SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote( ISteamMusicRemote* self );
|
||||
S_API bool SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote( ISteamMusicRemote* self );
|
||||
@ -548,8 +613,16 @@ S_API bool SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry( ISteamMusicRemote
|
||||
S_API bool SteamAPI_ISteamMusicRemote_PlaylistDidChange( ISteamMusicRemote* self );
|
||||
|
||||
// ISteamHTTP
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamHTTP *SteamAPI_SteamHTTP_v003();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamHTTP(), but using this ensures that you are using a matching library.
|
||||
inline ISteamHTTP *SteamAPI_SteamHTTP() { return SteamAPI_SteamHTTP_v003(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamHTTP *SteamAPI_SteamGameServerHTTP_v003();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerHTTP(), but using this ensures that you are using a matching library.
|
||||
inline ISteamHTTP *SteamAPI_SteamGameServerHTTP() { return SteamAPI_SteamGameServerHTTP_v003(); }
|
||||
S_API HTTPRequestHandle SteamAPI_ISteamHTTP_CreateHTTPRequest( ISteamHTTP* self, EHTTPMethod eHTTPRequestMethod, const char * pchAbsoluteURL );
|
||||
S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestContextValue( ISteamHTTP* self, HTTPRequestHandle hRequest, uint64 ulContextValue );
|
||||
S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout( ISteamHTTP* self, HTTPRequestHandle hRequest, uint32 unTimeoutSeconds );
|
||||
@ -577,7 +650,11 @@ S_API bool SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS( ISteamHTTP* self
|
||||
S_API bool SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut( ISteamHTTP* self, HTTPRequestHandle hRequest, bool * pbWasTimedOut );
|
||||
|
||||
// ISteamInput
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamInput *SteamAPI_SteamInput_v005();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamInput(), but using this ensures that you are using a matching library.
|
||||
inline ISteamInput *SteamAPI_SteamInput() { return SteamAPI_SteamInput_v005(); }
|
||||
S_API bool SteamAPI_ISteamInput_Init( ISteamInput* self, bool bExplicitlyCallRunFrame );
|
||||
S_API bool SteamAPI_ISteamInput_Shutdown( ISteamInput* self );
|
||||
S_API bool SteamAPI_ISteamInput_SetInputActionManifestFilePath( ISteamInput* self, const char * pchInputActionManifestAbsolutePath );
|
||||
@ -627,7 +704,11 @@ S_API uint32 SteamAPI_ISteamInput_GetRemotePlaySessionID( ISteamInput* self, Inp
|
||||
S_API uint16 SteamAPI_ISteamInput_GetSessionInputConfigurationSettings( ISteamInput* self );
|
||||
|
||||
// ISteamController
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamController *SteamAPI_SteamController_v008();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamController(), but using this ensures that you are using a matching library.
|
||||
inline ISteamController *SteamAPI_SteamController() { return SteamAPI_SteamController_v008(); }
|
||||
S_API bool SteamAPI_ISteamController_Init( ISteamController* self );
|
||||
S_API bool SteamAPI_ISteamController_Shutdown( ISteamController* self );
|
||||
S_API void SteamAPI_ISteamController_RunFrame( ISteamController* self );
|
||||
@ -664,8 +745,16 @@ S_API EControllerActionOrigin SteamAPI_ISteamController_TranslateActionOrigin( I
|
||||
S_API bool SteamAPI_ISteamController_GetControllerBindingRevision( ISteamController* self, ControllerHandle_t controllerHandle, int * pMajor, int * pMinor );
|
||||
|
||||
// ISteamUGC
|
||||
S_API ISteamUGC *SteamAPI_SteamUGC_v015();
|
||||
S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v015();
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUGC *SteamAPI_SteamUGC_v016();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamUGC(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v016(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v016();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerUGC(), but using this ensures that you are using a matching library.
|
||||
inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v016(); }
|
||||
S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
|
||||
S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
|
||||
S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor );
|
||||
@ -702,6 +791,8 @@ S_API bool SteamAPI_ISteamUGC_SetCloudFileNameFilter( ISteamUGC* self, UGCQueryH
|
||||
S_API bool SteamAPI_ISteamUGC_SetMatchAnyTag( ISteamUGC* self, UGCQueryHandle_t handle, bool bMatchAnyTag );
|
||||
S_API bool SteamAPI_ISteamUGC_SetSearchText( ISteamUGC* self, UGCQueryHandle_t handle, const char * pSearchText );
|
||||
S_API bool SteamAPI_ISteamUGC_SetRankedByTrendDays( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unDays );
|
||||
S_API bool SteamAPI_ISteamUGC_SetTimeCreatedDateRange( ISteamUGC* self, UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd );
|
||||
S_API bool SteamAPI_ISteamUGC_SetTimeUpdatedDateRange( ISteamUGC* self, UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd );
|
||||
S_API bool SteamAPI_ISteamUGC_AddRequiredKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pKey, const char * pValue );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamUGC_RequestUGCDetails( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamUGC_CreateItem( ISteamUGC* self, AppId_t nConsumerAppId, EWorkshopFileType eFileType );
|
||||
@ -752,7 +843,11 @@ S_API bool SteamAPI_ISteamUGC_ShowWorkshopEULA( ISteamUGC* self );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamUGC_GetWorkshopEULAStatus( ISteamUGC* self );
|
||||
|
||||
// ISteamAppList
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamAppList *SteamAPI_SteamAppList_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamAppList(), but using this ensures that you are using a matching library.
|
||||
inline ISteamAppList *SteamAPI_SteamAppList() { return SteamAPI_SteamAppList_v001(); }
|
||||
S_API uint32 SteamAPI_ISteamAppList_GetNumInstalledApps( ISteamAppList* self );
|
||||
S_API uint32 SteamAPI_ISteamAppList_GetInstalledApps( ISteamAppList* self, AppId_t * pvecAppID, uint32 unMaxAppIDs );
|
||||
S_API int SteamAPI_ISteamAppList_GetAppName( ISteamAppList* self, AppId_t nAppID, char * pchName, int cchNameMax );
|
||||
@ -760,7 +855,11 @@ S_API int SteamAPI_ISteamAppList_GetAppInstallDir( ISteamAppList* self, AppId_t
|
||||
S_API int SteamAPI_ISteamAppList_GetAppBuildId( ISteamAppList* self, AppId_t nAppID );
|
||||
|
||||
// ISteamHTMLSurface
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamHTMLSurface *SteamAPI_SteamHTMLSurface_v005();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamHTMLSurface(), but using this ensures that you are using a matching library.
|
||||
inline ISteamHTMLSurface *SteamAPI_SteamHTMLSurface() { return SteamAPI_SteamHTMLSurface_v005(); }
|
||||
S_API bool SteamAPI_ISteamHTMLSurface_Init( ISteamHTMLSurface* self );
|
||||
S_API bool SteamAPI_ISteamHTMLSurface_Shutdown( ISteamHTMLSurface* self );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamHTMLSurface_CreateBrowser( ISteamHTMLSurface* self, const char * pchUserAgent, const char * pchUserCSS );
|
||||
@ -800,8 +899,16 @@ S_API void SteamAPI_ISteamHTMLSurface_JSDialogResponse( ISteamHTMLSurface* self,
|
||||
S_API void SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse( ISteamHTMLSurface* self, HHTMLBrowser unBrowserHandle, const char ** pchSelectedFiles );
|
||||
|
||||
// ISteamInventory
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamInventory *SteamAPI_SteamInventory_v003();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamInventory(), but using this ensures that you are using a matching library.
|
||||
inline ISteamInventory *SteamAPI_SteamInventory() { return SteamAPI_SteamInventory_v003(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamInventory *SteamAPI_SteamGameServerInventory_v003();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerInventory(), but using this ensures that you are using a matching library.
|
||||
inline ISteamInventory *SteamAPI_SteamGameServerInventory() { return SteamAPI_SteamGameServerInventory_v003(); }
|
||||
S_API EResult SteamAPI_ISteamInventory_GetResultStatus( ISteamInventory* self, SteamInventoryResult_t resultHandle );
|
||||
S_API bool SteamAPI_ISteamInventory_GetResultItems( ISteamInventory* self, SteamInventoryResult_t resultHandle, SteamItemDetails_t * pOutItemsArray, uint32 * punOutItemsArraySize );
|
||||
S_API bool SteamAPI_ISteamInventory_GetResultItemProperty( ISteamInventory* self, SteamInventoryResult_t resultHandle, uint32 unItemIndex, const char * pchPropertyName, char * pchValueBuffer, uint32 * punValueBufferSizeOut );
|
||||
@ -842,14 +949,22 @@ S_API bool SteamAPI_ISteamInventory_SubmitUpdateProperties( ISteamInventory* sel
|
||||
S_API bool SteamAPI_ISteamInventory_InspectItem( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const char * pchItemToken );
|
||||
|
||||
// ISteamVideo
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamVideo *SteamAPI_SteamVideo_v002();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamVideo(), but using this ensures that you are using a matching library.
|
||||
inline ISteamVideo *SteamAPI_SteamVideo() { return SteamAPI_SteamVideo_v002(); }
|
||||
S_API void SteamAPI_ISteamVideo_GetVideoURL( ISteamVideo* self, AppId_t unVideoAppID );
|
||||
S_API bool SteamAPI_ISteamVideo_IsBroadcasting( ISteamVideo* self, int * pnNumViewers );
|
||||
S_API void SteamAPI_ISteamVideo_GetOPFSettings( ISteamVideo* self, AppId_t unVideoAppID );
|
||||
S_API bool SteamAPI_ISteamVideo_GetOPFStringForApp( ISteamVideo* self, AppId_t unVideoAppID, char * pchBuffer, int32 * pnBufferSize );
|
||||
|
||||
// ISteamParentalSettings
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamParentalSettings *SteamAPI_SteamParentalSettings_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamParentalSettings(), but using this ensures that you are using a matching library.
|
||||
inline ISteamParentalSettings *SteamAPI_SteamParentalSettings() { return SteamAPI_SteamParentalSettings_v001(); }
|
||||
S_API bool SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled( ISteamParentalSettings* self );
|
||||
S_API bool SteamAPI_ISteamParentalSettings_BIsParentalLockLocked( ISteamParentalSettings* self );
|
||||
S_API bool SteamAPI_ISteamParentalSettings_BIsAppBlocked( ISteamParentalSettings* self, AppId_t nAppID );
|
||||
@ -858,7 +973,11 @@ S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureBlocked( ISteamParentalSett
|
||||
S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList( ISteamParentalSettings* self, EParentalFeature eFeature );
|
||||
|
||||
// ISteamRemotePlay
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamRemotePlay(), but using this ensures that you are using a matching library.
|
||||
inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v001(); }
|
||||
S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionCount( ISteamRemotePlay* self );
|
||||
S_API RemotePlaySessionID_t SteamAPI_ISteamRemotePlay_GetSessionID( ISteamRemotePlay* self, int iSessionIndex );
|
||||
S_API uint64_steamid SteamAPI_ISteamRemotePlay_GetSessionSteamID( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
|
||||
@ -868,18 +987,34 @@ S_API bool SteamAPI_ISteamRemotePlay_BGetSessionClientResolution( ISteamRemotePl
|
||||
S_API bool SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite( ISteamRemotePlay* self, uint64_steamid steamIDFriend );
|
||||
|
||||
// ISteamNetworkingMessages
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI_v002();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingMessages_SteamAPI(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI() { return SteamAPI_SteamNetworkingMessages_SteamAPI_v002(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworkingMessages_SteamAPI(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI() { return SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002(); }
|
||||
S_API EResult SteamAPI_ISteamNetworkingMessages_SendMessageToUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, const void * pubData, uint32 cubData, int nSendFlags, int nRemoteChannel );
|
||||
S_API int SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel( ISteamNetworkingMessages* self, int nLocalChannel, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages );
|
||||
S_API bool SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote );
|
||||
S_API bool SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote );
|
||||
S_API bool SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, int nLocalChannel );
|
||||
S_API ESteamNetworkingConnectionState SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, SteamNetConnectionInfo_t * pConnectionInfo, SteamNetworkingQuickConnectionStatus * pQuickStatus );
|
||||
S_API ESteamNetworkingConnectionState SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, SteamNetConnectionInfo_t * pConnectionInfo, SteamNetConnectionRealTimeStatus_t * pQuickStatus );
|
||||
|
||||
// ISteamNetworkingSockets
|
||||
S_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v011();
|
||||
S_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011();
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v012();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingSockets_SteamAPI(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI() { return SteamAPI_SteamNetworkingSockets_SteamAPI_v012(); }
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerNetworkingSockets_SteamAPI(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI() { return SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012(); }
|
||||
S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP( ISteamNetworkingSockets* self, const SteamNetworkingIPAddr & localAddress, int nOptions, const SteamNetworkingConfigValue_t * pOptions );
|
||||
S_API HSteamNetConnection SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress( ISteamNetworkingSockets* self, const SteamNetworkingIPAddr & address, int nOptions, const SteamNetworkingConfigValue_t * pOptions );
|
||||
S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P( ISteamNetworkingSockets* self, int nLocalVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions );
|
||||
@ -896,10 +1031,11 @@ S_API void SteamAPI_ISteamNetworkingSockets_SendMessages( ISteamNetworkingSocket
|
||||
S_API EResult SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn );
|
||||
S_API int SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_GetConnectionInfo( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetConnectionInfo_t * pInfo );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus * pStats );
|
||||
S_API EResult SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetConnectionRealTimeStatus_t * pStatus, int nLanes, SteamNetConnectionRealTimeLaneStatus_t * pLanes );
|
||||
S_API int SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus( ISteamNetworkingSockets* self, HSteamNetConnection hConn, char * pszBuf, int cbBuf );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress( ISteamNetworkingSockets* self, HSteamListenSocket hSocket, SteamNetworkingIPAddr * address );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_CreateSocketPair( ISteamNetworkingSockets* self, HSteamNetConnection * pOutConnection1, HSteamNetConnection * pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity * pIdentity1, const SteamNetworkingIdentity * pIdentity2 );
|
||||
S_API EResult SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes( ISteamNetworkingSockets* self, HSteamNetConnection hConn, int nNumLanes, const int * pLanePriorities, const uint16 * pLaneWeights );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_GetIdentity( ISteamNetworkingSockets* self, SteamNetworkingIdentity * pIdentity );
|
||||
S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingSockets_InitAuthentication( ISteamNetworkingSockets* self );
|
||||
S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus( ISteamNetworkingSockets* self, SteamNetAuthenticationStatus_t * pDetails );
|
||||
@ -921,9 +1057,18 @@ S_API bool SteamAPI_ISteamNetworkingSockets_GetCertificateRequest( ISteamNetwork
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_SetCertificate( ISteamNetworkingSockets* self, const void * pCertificate, int cbCertificate, SteamNetworkingErrMsg & errMsg );
|
||||
S_API void SteamAPI_ISteamNetworkingSockets_ResetIdentity( ISteamNetworkingSockets* self, const SteamNetworkingIdentity * pIdentity );
|
||||
S_API void SteamAPI_ISteamNetworkingSockets_RunCallbacks( ISteamNetworkingSockets* self );
|
||||
S_API bool SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP( ISteamNetworkingSockets* self, int nNumPorts );
|
||||
S_API void SteamAPI_ISteamNetworkingSockets_GetFakeIP( ISteamNetworkingSockets* self, int idxFirstPort, SteamNetworkingFakeIPResult_t * pInfo );
|
||||
S_API HSteamListenSocket SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP( ISteamNetworkingSockets* self, int idxFakePort, int nOptions, const SteamNetworkingConfigValue_t * pOptions );
|
||||
S_API EResult SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection( ISteamNetworkingSockets* self, HSteamNetConnection hConn, SteamNetworkingIPAddr * pOutAddr );
|
||||
S_API ISteamNetworkingFakeUDPPort * SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort( ISteamNetworkingSockets* self, int idxFakeServerPort );
|
||||
|
||||
// ISteamNetworkingUtils
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI_v004();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamNetworkingUtils_SteamAPI(), but using this ensures that you are using a matching library.
|
||||
inline ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI() { return SteamAPI_SteamNetworkingUtils_SteamAPI_v004(); }
|
||||
S_API SteamNetworkingMessage_t * SteamAPI_ISteamNetworkingUtils_AllocateMessage( ISteamNetworkingUtils* self, int cbAllocateBuffer );
|
||||
S_API void SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess( ISteamNetworkingUtils* self );
|
||||
S_API ESteamNetworkingAvailability SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus( ISteamNetworkingUtils* self, SteamRelayNetworkStatus_t * pDetails );
|
||||
@ -939,6 +1084,9 @@ S_API int SteamAPI_ISteamNetworkingUtils_GetPOPCount( ISteamNetworkingUtils* sel
|
||||
S_API int SteamAPI_ISteamNetworkingUtils_GetPOPList( ISteamNetworkingUtils* self, SteamNetworkingPOPID * list, int nListSz );
|
||||
S_API SteamNetworkingMicroseconds SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp( ISteamNetworkingUtils* self );
|
||||
S_API void SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction( ISteamNetworkingUtils* self, ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_IsFakeIPv4( ISteamNetworkingUtils* self, uint32 nIPv4 );
|
||||
S_API ESteamNetworkingFakeIPType SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType( ISteamNetworkingUtils* self, uint32 nIPv4 );
|
||||
S_API EResult SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & fakeIP, SteamNetworkingIdentity * pOutRealIdentity );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, int32 val );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, float val );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, const char * val );
|
||||
@ -949,6 +1097,7 @@ S_API bool SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString( ISteam
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged( ISteamNetworkingUtils* self, FnSteamNetConnectionStatusChanged fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged( ISteamNetworkingUtils* self, FnSteamNetAuthenticationStatusChanged fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged( ISteamNetworkingUtils* self, FnSteamRelayNetworkStatusChanged fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult( ISteamNetworkingUtils* self, FnSteamNetworkingFakeIPResult fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest( ISteamNetworkingUtils* self, FnSteamNetworkingMessagesSessionRequest fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed( ISteamNetworkingUtils* self, FnSteamNetworkingMessagesSessionFailed fnCallback );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SetConfigValue( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType eDataType, const void * pArg );
|
||||
@ -958,11 +1107,16 @@ S_API const char * SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo( ISteamNetw
|
||||
S_API ESteamNetworkingConfigValue SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues( ISteamNetworkingUtils* self, ESteamNetworkingConfigValue eCurrent, bool bEnumerateDevVars );
|
||||
S_API void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & addr, char * buf, uint32 cbBuf, bool bWithPort );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString( ISteamNetworkingUtils* self, SteamNetworkingIPAddr * pAddr, const char * pszStr );
|
||||
S_API ESteamNetworkingFakeIPType SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType( ISteamNetworkingUtils* self, const SteamNetworkingIPAddr & addr );
|
||||
S_API void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString( ISteamNetworkingUtils* self, const SteamNetworkingIdentity & identity, char * buf, uint32 cbBuf );
|
||||
S_API bool SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString( ISteamNetworkingUtils* self, SteamNetworkingIdentity * pIdentity, const char * pszStr );
|
||||
|
||||
// ISteamGameServer
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamGameServer *SteamAPI_SteamGameServer_v014();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServer(), but using this ensures that you are using a matching library.
|
||||
inline ISteamGameServer *SteamAPI_SteamGameServer() { return SteamAPI_SteamGameServer_v014(); }
|
||||
S_API void SteamAPI_ISteamGameServer_SetProduct( ISteamGameServer* self, const char * pszProduct );
|
||||
S_API void SteamAPI_ISteamGameServer_SetGameDescription( ISteamGameServer* self, const char * pszGameDescription );
|
||||
S_API void SteamAPI_ISteamGameServer_SetModDir( ISteamGameServer* self, const char * pszModDir );
|
||||
@ -1006,7 +1160,11 @@ S_API void SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED( ISteamGameSe
|
||||
S_API bool SteamAPI_ISteamGameServer_BUpdateUserData( ISteamGameServer* self, uint64_steamid steamIDUser, const char * pchPlayerName, uint32 uScore );
|
||||
|
||||
// ISteamGameServerStats
|
||||
|
||||
// A versioned accessor is exported by the library
|
||||
S_API ISteamGameServerStats *SteamAPI_SteamGameServerStats_v001();
|
||||
// Inline, unversioned accessor to get the current version. Essentially the same as SteamGameServerStats(), but using this ensures that you are using a matching library.
|
||||
inline ISteamGameServerStats *SteamAPI_SteamGameServerStats() { return SteamAPI_SteamGameServerStats_v001(); }
|
||||
S_API SteamAPICall_t SteamAPI_ISteamGameServerStats_RequestUserStats( ISteamGameServerStats* self, uint64_steamid steamIDUser );
|
||||
S_API bool SteamAPI_ISteamGameServerStats_GetUserStatInt32( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, int32 * pData );
|
||||
S_API bool SteamAPI_ISteamGameServerStats_GetUserStatFloat( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName, float * pData );
|
||||
@ -1018,6 +1176,12 @@ S_API bool SteamAPI_ISteamGameServerStats_SetUserAchievement( ISteamGameServerSt
|
||||
S_API bool SteamAPI_ISteamGameServerStats_ClearUserAchievement( ISteamGameServerStats* self, uint64_steamid steamIDUser, const char * pchName );
|
||||
S_API SteamAPICall_t SteamAPI_ISteamGameServerStats_StoreUserStats( ISteamGameServerStats* self, uint64_steamid steamIDUser );
|
||||
|
||||
// ISteamNetworkingFakeUDPPort
|
||||
S_API void SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort( ISteamNetworkingFakeUDPPort* self );
|
||||
S_API EResult SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP( ISteamNetworkingFakeUDPPort* self, const SteamNetworkingIPAddr & remoteAddress, const void * pData, uint32 cbData, int nSendFlags );
|
||||
S_API int SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages( ISteamNetworkingFakeUDPPort* self, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages );
|
||||
S_API void SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup( ISteamNetworkingFakeUDPPort* self, const SteamNetworkingIPAddr & remoteAddress );
|
||||
|
||||
// SteamIPAddress_t
|
||||
S_API bool SteamAPI_SteamIPAddress_t_IsSet( SteamIPAddress_t* self );
|
||||
|
||||
@ -1055,6 +1219,8 @@ S_API bool SteamAPI_SteamNetworkingIPAddr_IsLocalHost( SteamNetworkingIPAddr* se
|
||||
S_API void SteamAPI_SteamNetworkingIPAddr_ToString( SteamNetworkingIPAddr* self, char * buf, uint32 cbBuf, bool bWithPort );
|
||||
S_API bool SteamAPI_SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr* self, const char * pszStr );
|
||||
S_API bool SteamAPI_SteamNetworkingIPAddr_IsEqualTo( SteamNetworkingIPAddr* self, const SteamNetworkingIPAddr & x );
|
||||
S_API ESteamNetworkingFakeIPType SteamAPI_SteamNetworkingIPAddr_GetFakeIPType( SteamNetworkingIPAddr* self );
|
||||
S_API bool SteamAPI_SteamNetworkingIPAddr_IsFakeIP( SteamNetworkingIPAddr* self );
|
||||
|
||||
// SteamNetworkingIdentity
|
||||
S_API void SteamAPI_SteamNetworkingIdentity_Clear( SteamNetworkingIdentity* self );
|
||||
@ -1071,6 +1237,10 @@ S_API void SteamAPI_SteamNetworkingIdentity_SetStadiaID( SteamNetworkingIdentity
|
||||
S_API uint64 SteamAPI_SteamNetworkingIdentity_GetStadiaID( SteamNetworkingIdentity* self );
|
||||
S_API void SteamAPI_SteamNetworkingIdentity_SetIPAddr( SteamNetworkingIdentity* self, const SteamNetworkingIPAddr & addr );
|
||||
S_API const SteamNetworkingIPAddr * SteamAPI_SteamNetworkingIdentity_GetIPAddr( SteamNetworkingIdentity* self );
|
||||
S_API void SteamAPI_SteamNetworkingIdentity_SetIPv4Addr( SteamNetworkingIdentity* self, uint32 nIPv4, uint16 nPort );
|
||||
S_API uint32 SteamAPI_SteamNetworkingIdentity_GetIPv4( SteamNetworkingIdentity* self );
|
||||
S_API ESteamNetworkingFakeIPType SteamAPI_SteamNetworkingIdentity_GetFakeIPType( SteamNetworkingIdentity* self );
|
||||
S_API bool SteamAPI_SteamNetworkingIdentity_IsFakeIP( SteamNetworkingIdentity* self );
|
||||
S_API void SteamAPI_SteamNetworkingIdentity_SetLocalHost( SteamNetworkingIdentity* self );
|
||||
S_API bool SteamAPI_SteamNetworkingIdentity_IsLocalHost( SteamNetworkingIdentity* self );
|
||||
S_API bool SteamAPI_SteamNetworkingIdentity_SetGenericString( SteamNetworkingIdentity* self, const char * pszString );
|
||||
@ -1091,15 +1261,6 @@ S_API void SteamAPI_SteamNetworkingConfigValue_t_SetFloat( SteamNetworkingConfig
|
||||
S_API void SteamAPI_SteamNetworkingConfigValue_t_SetPtr( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, void * data );
|
||||
S_API void SteamAPI_SteamNetworkingConfigValue_t_SetString( SteamNetworkingConfigValue_t* self, ESteamNetworkingConfigValue eVal, const char * data );
|
||||
|
||||
// SteamNetworkingPOPIDRender
|
||||
S_API const char * SteamAPI_SteamNetworkingPOPIDRender_c_str( SteamNetworkingPOPIDRender* self );
|
||||
|
||||
// SteamNetworkingIdentityRender
|
||||
S_API const char * SteamAPI_SteamNetworkingIdentityRender_c_str( SteamNetworkingIdentityRender* self );
|
||||
|
||||
// SteamNetworkingIPAddrRender
|
||||
S_API const char * SteamAPI_SteamNetworkingIPAddrRender_c_str( SteamNetworkingIPAddrRender* self );
|
||||
|
||||
// SteamDatagramHostedAddress
|
||||
S_API void SteamAPI_SteamDatagramHostedAddress_Clear( SteamDatagramHostedAddress* self );
|
||||
S_API SteamNetworkingPOPID SteamAPI_SteamDatagramHostedAddress_GetPopID( SteamDatagramHostedAddress* self );
|
||||
|
||||
@ -255,64 +255,38 @@ enum { k_iSteamBillingCallbacks = 400 };
|
||||
enum { k_iSteamMatchmakingCallbacks = 500 };
|
||||
enum { k_iSteamContentServerCallbacks = 600 };
|
||||
enum { k_iSteamUtilsCallbacks = 700 };
|
||||
enum { k_iClientFriendsCallbacks = 800 };
|
||||
enum { k_iClientUserCallbacks = 900 };
|
||||
enum { k_iSteamAppsCallbacks = 1000 };
|
||||
enum { k_iSteamUserStatsCallbacks = 1100 };
|
||||
enum { k_iSteamNetworkingCallbacks = 1200 };
|
||||
enum { k_iSteamNetworkingSocketsCallbacks = 1220 };
|
||||
enum { k_iSteamNetworkingMessagesCallbacks = 1250 };
|
||||
enum { k_iSteamNetworkingUtilsCallbacks = 1280 };
|
||||
enum { k_iClientRemoteStorageCallbacks = 1300 };
|
||||
enum { k_iClientDepotBuilderCallbacks = 1400 };
|
||||
enum { k_iSteamRemoteStorageCallbacks = 1300 };
|
||||
enum { k_iSteamGameServerItemsCallbacks = 1500 };
|
||||
enum { k_iClientUtilsCallbacks = 1600 };
|
||||
enum { k_iSteamGameCoordinatorCallbacks = 1700 };
|
||||
enum { k_iSteamGameServerStatsCallbacks = 1800 };
|
||||
enum { k_iSteam2AsyncCallbacks = 1900 };
|
||||
enum { k_iSteamGameStatsCallbacks = 2000 };
|
||||
enum { k_iClientHTTPCallbacks = 2100 };
|
||||
enum { k_iClientScreenshotsCallbacks = 2200 };
|
||||
enum { k_iSteamHTTPCallbacks = 2100 };
|
||||
enum { k_iSteamScreenshotsCallbacks = 2300 };
|
||||
enum { k_iClientAudioCallbacks = 2400 };
|
||||
enum { k_iClientUnifiedMessagesCallbacks = 2500 };
|
||||
enum { k_iSteamStreamLauncherCallbacks = 2600 };
|
||||
enum { k_iClientControllerCallbacks = 2700 };
|
||||
enum { k_iSteamControllerCallbacks = 2800 };
|
||||
enum { k_iClientParentalSettingsCallbacks = 2900 };
|
||||
enum { k_iClientDeviceAuthCallbacks = 3000 };
|
||||
enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
|
||||
enum { k_iClientMusicCallbacks = 3200 };
|
||||
enum { k_iClientRemoteClientManagerCallbacks = 3300 };
|
||||
enum { k_iClientUGCCallbacks = 3400 };
|
||||
enum { k_iSteamUGCCallbacks = 3400 };
|
||||
enum { k_iSteamStreamClientCallbacks = 3500 };
|
||||
enum { k_IClientProductBuilderCallbacks = 3600 };
|
||||
enum { k_iClientShortcutsCallbacks = 3700 };
|
||||
enum { k_iClientRemoteControlManagerCallbacks = 3800 };
|
||||
enum { k_iSteamAppListCallbacks = 3900 };
|
||||
enum { k_iSteamMusicCallbacks = 4000 };
|
||||
enum { k_iSteamMusicRemoteCallbacks = 4100 };
|
||||
enum { k_iClientVRCallbacks = 4200 };
|
||||
enum { k_iClientGameNotificationCallbacks = 4300 };
|
||||
enum { k_iSteamGameNotificationCallbacks = 4400 };
|
||||
enum { k_iSteamHTMLSurfaceCallbacks = 4500 };
|
||||
enum { k_iClientVideoCallbacks = 4600 };
|
||||
enum { k_iClientInventoryCallbacks = 4700 };
|
||||
enum { k_iClientBluetoothManagerCallbacks = 4800 };
|
||||
enum { k_iClientSharedConnectionCallbacks = 4900 };
|
||||
enum { k_iSteamVideoCallbacks = 4600 };
|
||||
enum { k_iSteamInventoryCallbacks = 4700 };
|
||||
enum { k_ISteamParentalSettingsCallbacks = 5000 };
|
||||
enum { k_iClientShaderCallbacks = 5100 };
|
||||
enum { k_iSteamGameSearchCallbacks = 5200 };
|
||||
enum { k_iSteamPartiesCallbacks = 5300 };
|
||||
enum { k_iClientPartiesCallbacks = 5400 };
|
||||
enum { k_iSteamSTARCallbacks = 5500 };
|
||||
enum { k_iClientSTARCallbacks = 5600 };
|
||||
enum { k_iSteamRemotePlayCallbacks = 5700 };
|
||||
enum { k_iClientCompatCallbacks = 5800 };
|
||||
enum { k_iSteamChatCallbacks = 5900 };
|
||||
enum { k_iClientNetworkingUtilsCallbacks = 6000 };
|
||||
enum { k_iClientSystemManagerCallbacks = 6100 };
|
||||
enum { k_iClientStorageDeviceManagerCallbacks = 6200 };
|
||||
// NOTE: Internal "IClientXxx" callback IDs go in clientenums.h
|
||||
|
||||
#ifdef _MSVC_VER
|
||||
#pragma warning( pop )
|
||||
|
||||
@ -136,6 +136,7 @@ enum EResult
|
||||
k_EResultSteamRealmMismatch = 120, // The user's realm does not match the realm of the requested resource
|
||||
k_EResultInvalidSignature = 121, // signature check did not match
|
||||
k_EResultParseFailure = 122, // Failed to parse input
|
||||
k_EResultNoVerifiedPhone = 123, // account does not have a verified phone number
|
||||
};
|
||||
|
||||
// Error codes for use with the voice functions
|
||||
|
||||
135
Generator/steam_sdk/steamnetworkingfakeip.h
Normal file
135
Generator/steam_sdk/steamnetworkingfakeip.h
Normal file
@ -0,0 +1,135 @@
|
||||
//====== Copyright Valve Corporation, All rights reserved. ====================
|
||||
|
||||
#ifndef STEAMNETWORKINGFAKEIP_H
|
||||
#define STEAMNETWORKINGFAKEIP_H
|
||||
#pragma once
|
||||
|
||||
#include "steamnetworkingtypes.h"
|
||||
#include "steam_api_common.h"
|
||||
|
||||
// It is HIGHLY recommended to limit messages sent via Fake UDP port to this
|
||||
// value. The purpose of a Fake UDP port is to make porting ordinary ad-hoc UDP
|
||||
// code easier. Although the real MTU might be higher than this, this particular
|
||||
// conservative value is chosen so that fragmentation won't be occurring and
|
||||
// hiding performance problems from you.
|
||||
constexpr int k_cbSteamNetworkingSocketsFakeUDPPortRecommendedMTU = 1200;
|
||||
|
||||
// Messages larger than this size are not allowed and cannot be sent
|
||||
// via Fake UDP port.
|
||||
constexpr int k_cbSteamNetworkingSocketsFakeUDPPortMaxMessageSize = 4096;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
/// ISteamNetworkingFakeUDPPort
|
||||
///
|
||||
/// Acts like a UDP port, sending and receiving datagrams addressed using
|
||||
/// FakeIP addresses.
|
||||
///
|
||||
/// See: ISteamNetworkingSockets::CreateFakeUDPPort
|
||||
|
||||
class ISteamNetworkingFakeUDPPort
|
||||
{
|
||||
public:
|
||||
/// Destroy the object and cleanup any internal connections.
|
||||
/// Note that this function call is not threadsafe with respect
|
||||
/// to any other method of this interface. (However, in general
|
||||
/// all other operations are threadsafe with respect to each other.)
|
||||
virtual void DestroyFakeUDPPort() = 0;
|
||||
|
||||
/// Send a datagram to the specified FakeIP.
|
||||
///
|
||||
/// See ISteamNetworkingSockets::SendMessageToConnection for the meaning of
|
||||
/// nSendFlags and possible return codes.
|
||||
///
|
||||
/// Notes:
|
||||
/// - datagrams larger than the underlying MTU are supported, but
|
||||
/// reliable messages (k_nSteamNetworkingSend_Reliable) are not supported.
|
||||
/// - You will usually want to use k_nSteamNetworkingSend_NoNagle
|
||||
/// - k_EResultBusy is returned if this is a "server" port and the global
|
||||
/// allocation has not yet completed.
|
||||
/// - k_EResultIPNotFound will be returned if the address is a local/ephemeral
|
||||
/// address and no existing connection can be found. This can happen if
|
||||
/// the remote host contacted us without having a global address, and we
|
||||
/// assigned them a random local address, and then the session with
|
||||
/// that host timed out.
|
||||
/// - When initiating communications, the first messages may be sent
|
||||
/// via backend signaling, or otherwise delayed, while a route is found.
|
||||
/// Expect the ping time to fluctuate during this period, and it's possible
|
||||
/// that messages will be delivered out of order (which is also possible with
|
||||
/// ordinary UDP).
|
||||
virtual EResult SendMessageToFakeIP( const SteamNetworkingIPAddr &remoteAddress, const void *pData, uint32 cbData, int nSendFlags ) = 0;
|
||||
|
||||
/// Receive messages on the port.
|
||||
///
|
||||
/// Returns the number of messages returned into your array, up to nMaxMessages.
|
||||
///
|
||||
/// SteamNetworkingMessage_t::m_identity in the returned message(s) will always contain
|
||||
/// a FakeIP. See ISteamNetworkingUtils::GetRealIdentityForFakeIP.
|
||||
virtual int ReceiveMessages( SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
|
||||
|
||||
/// Schedule the internal connection for a given peer to be cleaned up in a few seconds.
|
||||
///
|
||||
/// Idle connections automatically time out, and so this is not strictly *necessary*,
|
||||
/// but if you have reason to believe that you are done talking to a given peer for
|
||||
/// a while, you can call this to speed up the timeout. If any remaining packets are
|
||||
/// sent or received from the peer, the cleanup is canceled and the usual timeout
|
||||
/// value is restored. Thus you will usually call this immediately after sending
|
||||
/// or receiving application-layer "close connection" packets.
|
||||
virtual void ScheduleCleanup( const SteamNetworkingIPAddr &remoteAddress ) = 0;
|
||||
};
|
||||
|
||||
/// Callback struct used to notify when a connection has changed state
|
||||
#if defined( VALVE_CALLBACK_PACK_SMALL )
|
||||
#pragma pack( push, 4 )
|
||||
#elif defined( VALVE_CALLBACK_PACK_LARGE )
|
||||
#pragma pack( push, 8 )
|
||||
#else
|
||||
#error "Must define VALVE_CALLBACK_PACK_SMALL or VALVE_CALLBACK_PACK_LARGE"
|
||||
#endif
|
||||
|
||||
/// A struct used to describe a "fake IP" we have been assigned to
|
||||
/// use as an identifier. This callback is posted when
|
||||
/// ISteamNetworkingSoockets::BeginAsyncRequestFakeIP completes.
|
||||
/// See also ISteamNetworkingSockets::GetFakeIP
|
||||
struct SteamNetworkingFakeIPResult_t
|
||||
{
|
||||
enum { k_iCallback = k_iSteamNetworkingSocketsCallbacks + 3 };
|
||||
|
||||
/// Status/result of the allocation request. Possible failure values are:
|
||||
/// - k_EResultBusy - you called GetFakeIP but the request has not completed.
|
||||
/// - k_EResultInvalidParam - you called GetFakeIP with an invalid port index
|
||||
/// - k_EResultLimitExceeded - You asked for too many ports, or made an
|
||||
/// additional request after one had already succeeded
|
||||
/// - k_EResultNoMatch - GetFakeIP was called, but no request has been made
|
||||
///
|
||||
/// Note that, with the exception of k_EResultBusy (if you are polling),
|
||||
/// it is highly recommended to treat all failures as fatal.
|
||||
EResult m_eResult;
|
||||
|
||||
/// Local identity of the ISteamNetworkingSockets object that made
|
||||
/// this request and is assigned the IP. This is needed in the callback
|
||||
/// in the case where there are multiple ISteamNetworkingSockets objects.
|
||||
/// (E.g. one for the user, and another for the local gameserver).
|
||||
SteamNetworkingIdentity m_identity;
|
||||
|
||||
/// Fake IPv4 IP address that we have been assigned. NOTE: this
|
||||
/// IP address is not exclusively ours! Steam tries to avoid sharing
|
||||
/// IP addresses, but this may not always be possible. The IP address
|
||||
/// may be currently in use by another host, but with different port(s).
|
||||
/// The exact same IP:port address may have been used previously.
|
||||
/// Steam tries to avoid reusing ports until they have not been in use for
|
||||
/// some time, but this may not always be possible.
|
||||
uint32 m_unIP;
|
||||
|
||||
/// Port number(s) assigned to us. Only the first entries will contain
|
||||
/// nonzero values. Entries corresponding to ports beyond what was
|
||||
/// allocated for you will be zero.
|
||||
///
|
||||
/// (NOTE: At the time of this writing, the maximum number of ports you may
|
||||
/// request is 4.)
|
||||
enum { k_nMaxReturnPorts = 8 };
|
||||
uint16 m_unPorts[k_nMaxReturnPorts];
|
||||
};
|
||||
|
||||
#pragma pack( pop )
|
||||
|
||||
#endif // _H
|
||||
@ -57,12 +57,14 @@ struct SteamNetAuthenticationStatus_t;
|
||||
struct SteamRelayNetworkStatus_t;
|
||||
struct SteamNetworkingMessagesSessionRequest_t;
|
||||
struct SteamNetworkingMessagesSessionFailed_t;
|
||||
struct SteamNetworkingFakeIPResult_t;
|
||||
|
||||
typedef void (*FnSteamNetConnectionStatusChanged)( SteamNetConnectionStatusChangedCallback_t * );
|
||||
typedef void (*FnSteamNetAuthenticationStatusChanged)( SteamNetAuthenticationStatus_t * );
|
||||
typedef void (*FnSteamRelayNetworkStatusChanged)(SteamRelayNetworkStatus_t *);
|
||||
typedef void (*FnSteamNetworkingMessagesSessionRequest)(SteamNetworkingMessagesSessionRequest_t *);
|
||||
typedef void (*FnSteamNetworkingMessagesSessionFailed)(SteamNetworkingMessagesSessionFailed_t *);
|
||||
typedef void (*FnSteamNetworkingFakeIPResult)(SteamNetworkingFakeIPResult_t *);
|
||||
|
||||
/// Handle used to identify a connection to a remote host.
|
||||
typedef uint32 HSteamNetConnection;
|
||||
@ -176,6 +178,18 @@ enum ESteamNetworkingIdentityType
|
||||
k_ESteamNetworkingIdentityType__Force32bit = 0x7fffffff,
|
||||
};
|
||||
|
||||
/// "Fake IPs" are assigned to hosts, to make it easier to interface with
|
||||
/// older code that assumed all hosts will have an IPv4 address
|
||||
enum ESteamNetworkingFakeIPType
|
||||
{
|
||||
k_ESteamNetworkingFakeIPType_Invalid, // Error, argument was not even an IP address, etc.
|
||||
k_ESteamNetworkingFakeIPType_NotFake, // Argument was a valid IP, but was not from the reserved "fake" range
|
||||
k_ESteamNetworkingFakeIPType_GlobalIPv4, // Globally unique (for a given app) IPv4 address. Address space managed by Steam
|
||||
k_ESteamNetworkingFakeIPType_LocalIPv4, // Locally unique IPv4 address. Address space managed by the local process. For internal use only; should not be shared!
|
||||
|
||||
k_ESteamNetworkingFakeIPType__Force32Bit = 0x7fffffff
|
||||
};
|
||||
|
||||
#pragma pack(push,1)
|
||||
|
||||
/// Store an IP and port. IPv6 is always used; IPv4 is represented using
|
||||
@ -226,6 +240,13 @@ struct SteamNetworkingIPAddr
|
||||
|
||||
/// See if two addresses are identical
|
||||
bool operator==(const SteamNetworkingIPAddr &x ) const;
|
||||
|
||||
/// Classify address as FakeIP. This function never returns
|
||||
/// k_ESteamNetworkingFakeIPType_Invalid.
|
||||
ESteamNetworkingFakeIPType GetFakeIPType() const;
|
||||
|
||||
/// Return true if we are a FakeIP
|
||||
bool IsFakeIP() const { return GetFakeIPType() > k_ESteamNetworkingFakeIPType_NotFake; }
|
||||
};
|
||||
|
||||
/// An abstract way to represent the identity of a network host. All identities can
|
||||
@ -252,6 +273,11 @@ struct SteamNetworkingIdentity
|
||||
|
||||
void SetIPAddr( const SteamNetworkingIPAddr &addr ); // Set to specified IP:port
|
||||
const SteamNetworkingIPAddr *GetIPAddr() const; // returns null if we are not an IP address.
|
||||
void SetIPv4Addr( uint32 nIPv4, uint16 nPort ); // Set to specified IPv4:port
|
||||
uint32 GetIPv4() const; // returns 0 if we are not an IPv4 address.
|
||||
|
||||
ESteamNetworkingFakeIPType GetFakeIPType() const;
|
||||
bool IsFakeIP() const { return GetFakeIPType() > k_ESteamNetworkingFakeIPType_NotFake; }
|
||||
|
||||
// "localhost" is equivalent for many purposes to "anonymous." Our remote
|
||||
// will identify us by the network address we use.
|
||||
@ -624,6 +650,16 @@ const int k_cchSteamNetworkingMaxConnectionCloseReason = 128;
|
||||
/// of a connection.
|
||||
const int k_cchSteamNetworkingMaxConnectionDescription = 128;
|
||||
|
||||
/// Max length of the app's part of the description
|
||||
const int k_cchSteamNetworkingMaxConnectionAppName = 32;
|
||||
|
||||
const int k_nSteamNetworkConnectionInfoFlags_Unauthenticated = 1; // We don't have a certificate for the remote host.
|
||||
const int k_nSteamNetworkConnectionInfoFlags_Unencrypted = 2; // Information is being sent out over a wire unencrypted (by this library)
|
||||
const int k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers = 4; // Internal loopback buffers. Won't be true for localhost. (You can check the address to determine that.) This implies k_nSteamNetworkConnectionInfoFlags_FastLAN
|
||||
const int k_nSteamNetworkConnectionInfoFlags_Fast = 8; // The connection is "fast" and "reliable". Either internal/localhost (check the address to find out), or the peer is on the same LAN. (Probably. It's based on the address and the ping time, this is actually hard to determine unambiguously).
|
||||
const int k_nSteamNetworkConnectionInfoFlags_Relayed = 16; // The connection is relayed somehow (SDR or TURN).
|
||||
const int k_nSteamNetworkConnectionInfoFlags_DualWifi = 32; // We're taking advantage of dual-wifi multi-path
|
||||
|
||||
/// Describe the state of a connection.
|
||||
struct SteamNetConnectionInfo_t
|
||||
{
|
||||
@ -671,13 +707,16 @@ struct SteamNetConnectionInfo_t
|
||||
/// handle, but in certain cases with symmetric connections it might not.
|
||||
char m_szConnectionDescription[ k_cchSteamNetworkingMaxConnectionDescription ];
|
||||
|
||||
/// Misc flags. Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx
|
||||
int m_nFlags;
|
||||
|
||||
/// Internal stuff, room to change API easily
|
||||
uint32 reserved[64];
|
||||
uint32 reserved[63];
|
||||
};
|
||||
|
||||
/// Quick connection state, pared down to something you could call
|
||||
/// more frequently without it being too big of a perf hit.
|
||||
struct SteamNetworkingQuickConnectionStatus
|
||||
struct SteamNetConnectionRealTimeStatus_t
|
||||
{
|
||||
|
||||
/// High level state of the connection
|
||||
@ -720,17 +759,16 @@ struct SteamNetworkingQuickConnectionStatus
|
||||
/// have to re-transmit.
|
||||
int m_cbSentUnackedReliable;
|
||||
|
||||
/// If you asked us to send a message right now, how long would that message
|
||||
/// sit in the queue before we actually started putting packets on the wire?
|
||||
/// (And assuming Nagle does not cause any packets to be delayed.)
|
||||
/// If you queued a message right now, approximately how long would that message
|
||||
/// wait in the queue before we actually started putting its data on the wire in
|
||||
/// a packet?
|
||||
///
|
||||
/// In general, data that is sent by the application is limited by the
|
||||
/// bandwidth of the channel. If you send data faster than this, it must
|
||||
/// be queued and put on the wire at a metered rate. Even sending a small amount
|
||||
/// of data (e.g. a few MTU, say ~3k) will require some of the data to be delayed
|
||||
/// a bit.
|
||||
///
|
||||
/// In general, the estimated delay will be approximately equal to
|
||||
/// In general, data that is sent by the application is limited by the bandwidth
|
||||
/// of the channel. If you send data faster than this, it must be queued and
|
||||
/// put on the wire at a metered rate. Even sending a small amount of data (e.g.
|
||||
/// a few MTU, say ~3k) will require some of the data to be delayed a bit.
|
||||
///
|
||||
/// Ignoring multiple lanes, the estimated delay will be approximately equal to
|
||||
///
|
||||
/// ( m_cbPendingUnreliable+m_cbPendingReliable ) / m_nSendRateBytesPerSecond
|
||||
///
|
||||
@ -739,15 +777,40 @@ struct SteamNetworkingQuickConnectionStatus
|
||||
/// and the last packet placed on the wire, and we are exactly up against the send
|
||||
/// rate limit. In that case we might need to wait for one packet's worth of time to
|
||||
/// elapse before we can send again. On the other extreme, the queue might have data
|
||||
/// in it waiting for Nagle. (This will always be less than one packet, because as soon
|
||||
/// as we have a complete packet we would send it.) In that case, we might be ready
|
||||
/// to send data now, and this value will be 0.
|
||||
/// in it waiting for Nagle. (This will always be less than one packet, because as
|
||||
/// soon as we have a complete packet we would send it.) In that case, we might be
|
||||
/// ready to send data now, and this value will be 0.
|
||||
///
|
||||
/// This value is only valid if multiple lanes are not used. If multiple lanes are
|
||||
/// in use, then the queue time will be different for each lane, and you must use
|
||||
/// the value in SteamNetConnectionRealTimeLaneStatus_t.
|
||||
///
|
||||
/// Nagle delay is ignored for the purposes of this calculation.
|
||||
SteamNetworkingMicroseconds m_usecQueueTime;
|
||||
|
||||
/// Internal stuff, room to change API easily
|
||||
// Internal stuff, room to change API easily
|
||||
uint32 reserved[16];
|
||||
};
|
||||
|
||||
/// Quick status of a particular lane
|
||||
struct SteamNetConnectionRealTimeLaneStatus_t
|
||||
{
|
||||
// Counters for this particular lane. See the corresponding variables
|
||||
// in SteamNetConnectionRealTimeStatus_t
|
||||
int m_cbPendingUnreliable;
|
||||
int m_cbPendingReliable;
|
||||
int m_cbSentUnackedReliable;
|
||||
int _reservePad1; // Reserved for future use
|
||||
|
||||
/// Lane-specific queue time. This value takes into consideration lane priorities
|
||||
/// and weights, and how much data is queued in each lane, and attempts to predict
|
||||
/// how any data currently queued will be sent out.
|
||||
SteamNetworkingMicroseconds m_usecQueueTime;
|
||||
|
||||
// Internal stuff, room to change API easily
|
||||
uint32 reserved[10];
|
||||
};
|
||||
|
||||
#pragma pack( pop )
|
||||
|
||||
//
|
||||
@ -794,15 +857,17 @@ struct SteamNetworkingMessage_t
|
||||
/// - You might have closed the connection, so fetching the user data
|
||||
/// would not be possible.
|
||||
///
|
||||
/// Not used when sending messages,
|
||||
/// Not used when sending messages.
|
||||
int64 m_nConnUserData;
|
||||
|
||||
/// Local timestamp when the message was received
|
||||
/// Not used for outbound messages.
|
||||
SteamNetworkingMicroseconds m_usecTimeReceived;
|
||||
|
||||
/// Message number assigned by the sender.
|
||||
/// This is not used for outbound messages
|
||||
/// Message number assigned by the sender. This is not used for outbound
|
||||
/// messages. Note that if multiple lanes are used, each lane has its own
|
||||
/// message numbers, which are assigned sequentially, so messages from
|
||||
/// different lanes will share the same numbers.
|
||||
int64 m_nMessageNumber;
|
||||
|
||||
/// Function used to free up m_pData. This mechanism exists so that
|
||||
@ -834,6 +899,11 @@ struct SteamNetworkingMessage_t
|
||||
/// Not used for received messages.
|
||||
int64 m_nUserData;
|
||||
|
||||
/// For outbound messages, which lane to use? See ISteamNetworkingSockets::ConfigureConnectionLanes.
|
||||
/// For inbound messages, what lane was the message received on?
|
||||
uint16 m_idxLane;
|
||||
uint16 _pad1__;
|
||||
|
||||
/// You MUST call this when you're done with the object,
|
||||
/// to free up memory, etc.
|
||||
inline void Release();
|
||||
@ -1145,19 +1215,6 @@ enum ESteamNetworkingConfigValue
|
||||
/// the peer to also modify their value in order for encryption to be disabled.)
|
||||
k_ESteamNetworkingConfig_Unencrypted = 34,
|
||||
|
||||
/// [global int32] 0 or 1. Some variables are "dev" variables. They are useful
|
||||
/// for debugging, but should not be adjusted in production. When this flag is false (the default),
|
||||
/// such variables will not be enumerated by the ISteamnetworkingUtils::GetFirstConfigValue
|
||||
/// ISteamNetworkingUtils::GetConfigValueInfo functions. The idea here is that you
|
||||
/// can use those functions to provide a generic mechanism to set any configuration
|
||||
/// value from a console or configuration file, looking up the variable by name. Depending
|
||||
/// on your game, modifying other configuration values may also have negative effects, and
|
||||
/// you may wish to further lock down which variables are allowed to be modified by the user.
|
||||
/// (Maybe no variables!) Or maybe you use a whitelist or blacklist approach.
|
||||
///
|
||||
/// (This flag is itself a dev variable.)
|
||||
k_ESteamNetworkingConfig_EnumerateDevVars = 35,
|
||||
|
||||
/// [connection int32] Set this to 1 on outbound connections and listen sockets,
|
||||
/// to enable "symmetric connect mode", which is useful in the following
|
||||
/// common peer-to-peer use case:
|
||||
@ -1259,6 +1316,13 @@ enum ESteamNetworkingConfigValue
|
||||
/// This value should not be read or written in any other context.
|
||||
k_ESteamNetworkingConfig_LocalVirtualPort = 38,
|
||||
|
||||
/// [connection int32] Enable Dual wifi band support for this connection
|
||||
/// 0 = no, 1 = yes, 2 = simulate it for debugging, even if dual wifi not available
|
||||
k_ESteamNetworkingConfig_DualWifi_Enable = 39,
|
||||
|
||||
/// [connection int32] True to enable diagnostics reporting through
|
||||
/// generic platform UI. (Only available on Steam.)
|
||||
k_ESteamNetworkingConfig_EnableDiagnosticsUI = 46,
|
||||
|
||||
//
|
||||
// Simulating network conditions
|
||||
@ -1379,6 +1443,11 @@ enum ESteamNetworkingConfigValue
|
||||
/// ISteamNetworkingMessages.
|
||||
k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling = 206,
|
||||
|
||||
/// [global FnSteamNetworkingFakeIPResult] Callback that's invoked when
|
||||
/// a FakeIP allocation finishes. See: ISteamNetworkingSockets::BeginAsyncRequestFakeIP,
|
||||
/// ISteamNetworkingUtils::SetGlobalCallback_FakeIPResult
|
||||
k_ESteamNetworkingConfig_Callback_FakeIPResult = 207,
|
||||
|
||||
//
|
||||
// P2P connection settings
|
||||
//
|
||||
@ -1476,6 +1545,10 @@ enum ESteamNetworkingConfigValue
|
||||
k_ESteamNetworkingConfig_LogLevel_P2PRendezvous = 17, // [connection int32] P2P rendezvous messages
|
||||
k_ESteamNetworkingConfig_LogLevel_SDRRelayPings = 18, // [global int32] Ping relays
|
||||
|
||||
|
||||
// Deleted, do not use
|
||||
k_ESteamNetworkingConfig_DELETED_EnumerateDevVars = 35,
|
||||
|
||||
k_ESteamNetworkingConfigValue__Force32Bit = 0x7fffffff
|
||||
};
|
||||
|
||||
@ -1633,6 +1706,8 @@ inline void GetSteamNetworkingLocationPOPStringFromID( SteamNetworkingPOPID id,
|
||||
/// The POPID "dev" is used in non-production environments for testing.
|
||||
const SteamNetworkingPOPID k_SteamDatagramPOPID_dev = ( (uint32)'d' << 16U ) | ( (uint32)'e' << 8U ) | (uint32)'v';
|
||||
|
||||
#ifndef API_GEN
|
||||
|
||||
/// Utility class for printing a SteamNetworkingPOPID.
|
||||
struct SteamNetworkingPOPIDRender
|
||||
{
|
||||
@ -1642,6 +1717,7 @@ private:
|
||||
char buf[ 8 ];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
|
||||
Loading…
Reference in New Issue
Block a user