Merge branch 'master' into overlay_h
commit
884f147e1b
@ -0,0 +1,129 @@
|
|||||||
|
/* Copyright (C) 2019 Mr Goldberg
|
||||||
|
This file is part of the Goldberg Emulator
|
||||||
|
|
||||||
|
The Goldberg Emulator is free software; you can redistribute it and/or
|
||||||
|
modify it under the terms of the GNU Lesser General Public
|
||||||
|
License as published by the Free Software Foundation; either
|
||||||
|
version 3 of the License, or (at your option) any later version.
|
||||||
|
|
||||||
|
The Goldberg Emulator is distributed in the hope that it will be useful,
|
||||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
Lesser General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU Lesser General Public
|
||||||
|
License along with the Goldberg Emulator; if not, see
|
||||||
|
<http://www.gnu.org/licenses/>. */
|
||||||
|
|
||||||
|
#include "base.h"
|
||||||
|
|
||||||
|
class Steam_RemotePlay :
|
||||||
|
public ISteamRemotePlay
|
||||||
|
{
|
||||||
|
class Settings *settings;
|
||||||
|
class Networking *network;
|
||||||
|
class SteamCallResults *callback_results;
|
||||||
|
class SteamCallBacks *callbacks;
|
||||||
|
class RunEveryRunCB *run_every_runcb;
|
||||||
|
|
||||||
|
public:
|
||||||
|
static void steam_callback(void *object, Common_Message *msg)
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("steam_remoteplay_callback\n");
|
||||||
|
|
||||||
|
Steam_RemotePlay *steam_remoteplay = (Steam_RemotePlay *)object;
|
||||||
|
steam_remoteplay->Callback(msg);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void steam_run_every_runcb(void *object)
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("steam_remoteplay_run_every_runcb\n");
|
||||||
|
|
||||||
|
Steam_RemotePlay *steam_remoteplay = (Steam_RemotePlay *)object;
|
||||||
|
steam_remoteplay->RunCallbacks();
|
||||||
|
}
|
||||||
|
|
||||||
|
Steam_RemotePlay(class Settings *settings, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks, class RunEveryRunCB *run_every_runcb)
|
||||||
|
{
|
||||||
|
this->settings = settings;
|
||||||
|
this->network = network;
|
||||||
|
this->run_every_runcb = run_every_runcb;
|
||||||
|
//this->network->setCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &Steam_RemotePlay::steam_callback, this);
|
||||||
|
this->run_every_runcb->add(&Steam_RemotePlay::steam_run_every_runcb, this);
|
||||||
|
|
||||||
|
this->callback_results = callback_results;
|
||||||
|
this->callbacks = callbacks;
|
||||||
|
}
|
||||||
|
|
||||||
|
~Steam_RemotePlay()
|
||||||
|
{
|
||||||
|
//TODO rm network callbacks
|
||||||
|
this->run_every_runcb->remove(&Steam_RemotePlay::steam_run_every_runcb, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the number of currently connected Steam Remote Play sessions
|
||||||
|
uint32 GetSessionCount()
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::GetSessionCount\n");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the currently connected Steam Remote Play session ID at the specified index. Returns zero if index is out of bounds.
|
||||||
|
uint32 GetSessionID( int iSessionIndex )
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::GetSessionID\n");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the SteamID of the connected user
|
||||||
|
CSteamID GetSessionSteamID( uint32 unSessionID )
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::GetSessionSteamID\n");
|
||||||
|
return k_steamIDNil;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the name of the session client device
|
||||||
|
// This returns NULL if the sessionID is not valid
|
||||||
|
const char *GetSessionClientName( uint32 unSessionID )
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::GetSessionClientName\n");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the form factor of the session client device
|
||||||
|
ESteamDeviceFormFactor GetSessionClientFormFactor( uint32 unSessionID )
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::GetSessionClientFormFactor\n");
|
||||||
|
return k_ESteamDeviceFormFactorUnknown;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the resolution, in pixels, of the session client device
|
||||||
|
// This is set to 0x0 if the resolution is not available
|
||||||
|
bool BGetSessionClientResolution( uint32 unSessionID, int *pnResolutionX, int *pnResolutionY )
|
||||||
|
{
|
||||||
|
PRINT_DEBUG("Steam_RemotePlay::BGetSessionClientResolution\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void RunCallbacks()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void Callback(Common_Message *msg)
|
||||||
|
{
|
||||||
|
if (msg->has_low_level()) {
|
||||||
|
if (msg->low_level().type() == Low_Level::CONNECT) {
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
if (msg->low_level().type() == Low_Level::DISCONNECT) {
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (msg->has_networking_sockets()) {
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
@ -0,0 +1,142 @@
|
|||||||
|
|
||||||
|
#ifndef ISTEAMCLIENT018_H
|
||||||
|
#define ISTEAMCLIENT018_H
|
||||||
|
#ifdef STEAM_WIN32
|
||||||
|
#pragma once
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class ISteamClient018
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Creates a communication pipe to the Steam client.
|
||||||
|
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
|
||||||
|
virtual HSteamPipe CreateSteamPipe() = 0;
|
||||||
|
|
||||||
|
// Releases a previously created communications pipe
|
||||||
|
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
|
||||||
|
virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
|
||||||
|
|
||||||
|
// connects to an existing global user, failing if none exists
|
||||||
|
// used by the game to coordinate with the steamUI
|
||||||
|
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
|
||||||
|
virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
|
||||||
|
|
||||||
|
// used by game servers, create a steam user that won't be shared with anyone else
|
||||||
|
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
|
||||||
|
virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0;
|
||||||
|
|
||||||
|
// removes an allocated user
|
||||||
|
// NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
|
||||||
|
virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
|
||||||
|
|
||||||
|
// retrieves the ISteamUser interface associated with the handle
|
||||||
|
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// retrieves the ISteamGameServer interface associated with the handle
|
||||||
|
virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// set the local IP and Port to bind to
|
||||||
|
// this must be set before CreateLocalUser()
|
||||||
|
virtual void SetLocalIPBinding( uint32 unIP, uint16 usPort ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamFriends interface
|
||||||
|
virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamUtils interface
|
||||||
|
virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamMatchmaking interface
|
||||||
|
virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamMatchmakingServers interface
|
||||||
|
virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the a generic interface
|
||||||
|
virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamUserStats interface
|
||||||
|
virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns the ISteamGameServerStats interface
|
||||||
|
virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns apps interface
|
||||||
|
virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// networking
|
||||||
|
virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// remote storage
|
||||||
|
virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// user screenshots
|
||||||
|
virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// game search
|
||||||
|
virtual ISteamGameSearch *GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Deprecated. Applications should use SteamAPI_RunCallbacks() or SteamGameServer_RunCallbacks() instead.
|
||||||
|
STEAM_PRIVATE_API( virtual void RunFrame() = 0; )
|
||||||
|
|
||||||
|
// returns the number of IPC calls made since the last time this function was called
|
||||||
|
// Used for perf debugging so you can understand how many IPC calls your game makes per frame
|
||||||
|
// Every IPC call is at minimum a thread context switch if not a process one so you want to rate
|
||||||
|
// control how often you do them.
|
||||||
|
virtual uint32 GetIPCCallCount() = 0;
|
||||||
|
|
||||||
|
// API warning handling
|
||||||
|
// 'int' is the severity; 0 for msg, 1 for warning
|
||||||
|
// 'const char *' is the text of the message
|
||||||
|
// callbacks will occur directly after the API function is called that generated the warning or message.
|
||||||
|
virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0;
|
||||||
|
|
||||||
|
// Trigger global shutdown for the DLL
|
||||||
|
virtual bool BShutdownIfAllPipesClosed() = 0;
|
||||||
|
|
||||||
|
// Expose HTTP interface
|
||||||
|
virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Deprecated - the ISteamUnifiedMessages interface is no longer intended for public consumption.
|
||||||
|
STEAM_PRIVATE_API( virtual void *DEPRECATED_GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0 ; )
|
||||||
|
|
||||||
|
// Exposes the ISteamController interface - deprecated in favor of Steam Input
|
||||||
|
virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Exposes the ISteamUGC interface
|
||||||
|
virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// returns app list interface, only available on specially registered apps
|
||||||
|
virtual ISteamAppList *GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Music Player
|
||||||
|
virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Music Player Remote
|
||||||
|
virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
|
||||||
|
|
||||||
|
// html page display
|
||||||
|
virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
|
||||||
|
|
||||||
|
// Helper functions for internal Steam usage
|
||||||
|
STEAM_PRIVATE_API( virtual void DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; )
|
||||||
|
STEAM_PRIVATE_API( virtual void DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess( void (*)() ) = 0; )
|
||||||
|
STEAM_PRIVATE_API( virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0; )
|
||||||
|
|
||||||
|
// inventory
|
||||||
|
virtual ISteamInventory *GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Video
|
||||||
|
virtual ISteamVideo *GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Parental controls
|
||||||
|
virtual ISteamParentalSettings *GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Exposes the Steam Input interface for controller support
|
||||||
|
virtual ISteamInput *GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
// Steam Parties interface
|
||||||
|
virtual ISteamParties *GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // ISTEAMCLIENT018_H
|
@ -0,0 +1,381 @@
|
|||||||
|
|
||||||
|
#ifndef ISTEAMNETWORKINGSOCKETS002
|
||||||
|
#define ISTEAMNETWORKINGSOCKETS002
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
/// Lower level networking interface that more closely mirrors the standard
|
||||||
|
/// Berkeley sockets model. Sockets are hard! You should probably only use
|
||||||
|
/// this interface under the existing circumstances:
|
||||||
|
///
|
||||||
|
/// - You have an existing socket-based codebase you want to port, or coexist with.
|
||||||
|
/// - You want to be able to connect based on IP address, rather than (just) Steam ID.
|
||||||
|
/// - You need low-level control of bandwidth utilization, when to drop packets, etc.
|
||||||
|
///
|
||||||
|
/// Note that neither of the terms "connection" and "socket" will correspond
|
||||||
|
/// one-to-one with an underlying UDP socket. An attempt has been made to
|
||||||
|
/// keep the semantics as similar to the standard socket model when appropriate,
|
||||||
|
/// but some deviations do exist.
|
||||||
|
class ISteamNetworkingSockets002
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
|
||||||
|
/// Creates a "server" socket that listens for clients to connect to by
|
||||||
|
/// calling ConnectByIPAddress, over ordinary UDP (IPv4 or IPv6)
|
||||||
|
///
|
||||||
|
/// You must select a specific local port to listen on and set it
|
||||||
|
/// the port field of the local address.
|
||||||
|
///
|
||||||
|
/// Usually you wil set the IP portion of the address to zero, (SteamNetworkingIPAddr::Clear()).
|
||||||
|
/// This means that you will not bind to any particular local interface. In addition,
|
||||||
|
/// if possible the socket will be bound in "dual stack" mode, which means that it can
|
||||||
|
/// accept both IPv4 and IPv6 clients. If you wish to bind a particular interface, then
|
||||||
|
/// set the local address to the appropriate IPv4 or IPv6 IP.
|
||||||
|
///
|
||||||
|
/// When a client attempts to connect, a SteamNetConnectionStatusChangedCallback_t
|
||||||
|
/// will be posted. The connection will be in the connecting state.
|
||||||
|
virtual HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddress ) = 0;
|
||||||
|
|
||||||
|
/// Creates a connection and begins talking to a "server" over UDP at the
|
||||||
|
/// given IPv4 or IPv6 address. The remote host must be listening with a
|
||||||
|
/// matching call to CreateListenSocketIP on the specified port.
|
||||||
|
///
|
||||||
|
/// A SteamNetConnectionStatusChangedCallback_t callback will be triggered when we start
|
||||||
|
/// connecting, and then another one on either timeout or successful connection.
|
||||||
|
///
|
||||||
|
/// If the server does not have any identity configured, then their network address
|
||||||
|
/// will be the only identity in use. Or, the network host may provide a platform-specific
|
||||||
|
/// identity with or without a valid certificate to authenticate that identity. (These
|
||||||
|
/// details will be contained in the SteamNetConnectionStatusChangedCallback_t.) It's
|
||||||
|
/// up to your application to decide whether to allow the connection.
|
||||||
|
///
|
||||||
|
/// By default, all connections will get basic encryption sufficient to prevent
|
||||||
|
/// casual eavesdropping. But note that without certificates (or a shared secret
|
||||||
|
/// distributed through some other out-of-band mechanism), you don't have any
|
||||||
|
/// way of knowing who is actually on the other end, and thus are vulnerable to
|
||||||
|
/// man-in-the-middle attacks.
|
||||||
|
virtual HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address ) = 0;
|
||||||
|
|
||||||
|
#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
||||||
|
/// Like CreateListenSocketIP, but clients will connect using ConnectP2P
|
||||||
|
///
|
||||||
|
/// nVirtualPort specifies how clients can connect to this socket using
|
||||||
|
/// ConnectP2P. It's very common for applications to only have one listening socket;
|
||||||
|
/// in that case, use zero. If you need to open multiple listen sockets and have clients
|
||||||
|
/// be able to connect to one or the other, then nVirtualPort should be a small integer (<1000)
|
||||||
|
/// unique to each listen socket you create.
|
||||||
|
///
|
||||||
|
/// If you use this, you probably want to call ISteamNetworkingUtils::InitializeRelayNetworkAccess()
|
||||||
|
/// when your app initializes
|
||||||
|
virtual HSteamListenSocket CreateListenSocketP2P( int nVirtualPort ) = 0;
|
||||||
|
|
||||||
|
/// Begin connecting to a server that is identified using a platform-specific identifier.
|
||||||
|
/// This requires some sort of third party rendezvous service, and will depend on the
|
||||||
|
/// platform and what other libraries and services you are integrating with.
|
||||||
|
///
|
||||||
|
/// At the time of this writing, there is only one supported rendezvous service: Steam.
|
||||||
|
/// Set the SteamID (whether "user" or "gameserver") and Steam will determine if the
|
||||||
|
/// client is online and facilitate a relay connection. Note that all P2P connections on
|
||||||
|
/// Steam are currently relayed.
|
||||||
|
///
|
||||||
|
/// If you use this, you probably want to call ISteamNetworkingUtils::InitializeRelayNetworkAccess()
|
||||||
|
/// when your app initializes
|
||||||
|
virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, int nVirtualPort ) = 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Accept an incoming connection that has been received on a listen socket.
|
||||||
|
///
|
||||||
|
/// When a connection attempt is received (perhaps after a few basic handshake
|
||||||
|
/// packets have been exchanged to prevent trivial spoofing), a connection interface
|
||||||
|
/// object is created in the k_ESteamNetworkingConnectionState_Connecting state
|
||||||
|
/// and a SteamNetConnectionStatusChangedCallback_t is posted. At this point, your
|
||||||
|
/// application MUST either accept or close the connection. (It may not ignore it.)
|
||||||
|
/// Accepting the connection will transition it either into the connected state,
|
||||||
|
/// or the finding route state, depending on the connection type.
|
||||||
|
///
|
||||||
|
/// You should take action within a second or two, because accepting the connection is
|
||||||
|
/// what actually sends the reply notifying the client that they are connected. If you
|
||||||
|
/// delay taking action, from the client's perspective it is the same as the network
|
||||||
|
/// being unresponsive, and the client may timeout the connection attempt. In other
|
||||||
|
/// words, the client cannot distinguish between a delay caused by network problems
|
||||||
|
/// and a delay caused by the application.
|
||||||
|
///
|
||||||
|
/// This means that if your application goes for more than a few seconds without
|
||||||
|
/// processing callbacks (for example, while loading a map), then there is a chance
|
||||||
|
/// that a client may attempt to connect in that interval and fail due to timeout.
|
||||||
|
///
|
||||||
|
/// If the application does not respond to the connection attempt in a timely manner,
|
||||||
|
/// and we stop receiving communication from the client, the connection attempt will
|
||||||
|
/// be timed out locally, transitioning the connection to the
|
||||||
|
/// k_ESteamNetworkingConnectionState_ProblemDetectedLocally state. The client may also
|
||||||
|
/// close the connection before it is accepted, and a transition to the
|
||||||
|
/// k_ESteamNetworkingConnectionState_ClosedByPeer is also possible depending the exact
|
||||||
|
/// sequence of events.
|
||||||
|
///
|
||||||
|
/// Returns k_EResultInvalidParam if the handle is invalid.
|
||||||
|
/// Returns k_EResultInvalidState if the connection is not in the appropriate state.
|
||||||
|
/// (Remember that the connection state could change in between the time that the
|
||||||
|
/// notification being posted to the queue and when it is received by the application.)
|
||||||
|
virtual EResult AcceptConnection( HSteamNetConnection hConn ) = 0;
|
||||||
|
|
||||||
|
/// Disconnects from the remote host and invalidates the connection handle.
|
||||||
|
/// Any unread data on the connection is discarded.
|
||||||
|
///
|
||||||
|
/// nReason is an application defined code that will be received on the other
|
||||||
|
/// end and recorded (when possible) in backend analytics. The value should
|
||||||
|
/// come from a restricted range. (See ESteamNetConnectionEnd.) If you don't need
|
||||||
|
/// to communicate any information to the remote host, and do not want analytics to
|
||||||
|
/// be able to distinguish "normal" connection terminations from "exceptional" ones,
|
||||||
|
/// You may pass zero, in which case the generic value of
|
||||||
|
/// k_ESteamNetConnectionEnd_App_Generic will be used.
|
||||||
|
///
|
||||||
|
/// pszDebug is an optional human-readable diagnostic string that will be received
|
||||||
|
/// by the remote host and recorded (when possible) in backend analytics.
|
||||||
|
///
|
||||||
|
/// If you wish to put the socket into a "linger" state, where an attempt is made to
|
||||||
|
/// flush any remaining sent data, use bEnableLinger=true. Otherwise reliable data
|
||||||
|
/// is not flushed.
|
||||||
|
///
|
||||||
|
/// If the connection has already ended and you are just freeing up the
|
||||||
|
/// connection interface, the reason code, debug string, and linger flag are
|
||||||
|
/// ignored.
|
||||||
|
virtual bool CloseConnection( HSteamNetConnection hPeer, int nReason, const char *pszDebug, bool bEnableLinger ) = 0;
|
||||||
|
|
||||||
|
/// Destroy a listen socket. All the connections that were accepting on the listen
|
||||||
|
/// socket are closed ungracefully.
|
||||||
|
virtual bool CloseListenSocket( HSteamListenSocket hSocket ) = 0;
|
||||||
|
|
||||||
|
/// Set connection user data. the data is returned in the following places
|
||||||
|
/// - You can query it using GetConnectionUserData.
|
||||||
|
/// - The SteamNetworkingmessage_t structure.
|
||||||
|
/// - The SteamNetConnectionInfo_t structure. (Which is a member of SteamNetConnectionStatusChangedCallback_t.)
|
||||||
|
///
|
||||||
|
/// Returns false if the handle is invalid.
|
||||||
|
virtual bool SetConnectionUserData( HSteamNetConnection hPeer, int64 nUserData ) = 0;
|
||||||
|
|
||||||
|
/// Fetch connection user data. Returns -1 if handle is invalid
|
||||||
|
/// or if you haven't set any userdata on the connection.
|
||||||
|
virtual int64 GetConnectionUserData( HSteamNetConnection hPeer ) = 0;
|
||||||
|
|
||||||
|
/// Set a name for the connection, used mostly for debugging
|
||||||
|
virtual void SetConnectionName( HSteamNetConnection hPeer, const char *pszName ) = 0;
|
||||||
|
|
||||||
|
/// Fetch connection name. Returns false if handle is invalid
|
||||||
|
virtual bool GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen ) = 0;
|
||||||
|
|
||||||
|
/// Send a message to the remote host on the specified connection.
|
||||||
|
///
|
||||||
|
/// nSendFlags determines the delivery guarantees that will be provided,
|
||||||
|
/// when data should be buffered, etc. E.g. k_nSteamNetworkingSend_Unreliable
|
||||||
|
///
|
||||||
|
/// Note that the semantics we use for messages are not precisely
|
||||||
|
/// the same as the semantics of a standard "stream" socket.
|
||||||
|
/// (SOCK_STREAM) For an ordinary stream socket, the boundaries
|
||||||
|
/// between chunks are not considered relevant, and the sizes of
|
||||||
|
/// the chunks of data written will not necessarily match up to
|
||||||
|
/// the sizes of the chunks that are returned by the reads on
|
||||||
|
/// the other end. The remote host might read a partial chunk,
|
||||||
|
/// or chunks might be coalesced. For the message semantics
|
||||||
|
/// used here, however, the sizes WILL match. Each send call
|
||||||
|
/// will match a successful read call on the remote host
|
||||||
|
/// one-for-one. If you are porting existing stream-oriented
|
||||||
|
/// code to the semantics of reliable messages, your code should
|
||||||
|
/// work the same, since reliable message semantics are more
|
||||||
|
/// strict than stream semantics. The only caveat is related to
|
||||||
|
/// performance: there is per-message overhead to retain the
|
||||||
|
/// message sizes, and so if your code sends many small chunks
|
||||||
|
/// of data, performance will suffer. Any code based on stream
|
||||||
|
/// sockets that does not write excessively small chunks will
|
||||||
|
/// work without any changes.
|
||||||
|
///
|
||||||
|
/// Returns:
|
||||||
|
/// - k_EResultInvalidParam: invalid connection handle, or the individual message is too big.
|
||||||
|
/// (See k_cbMaxSteamNetworkingSocketsMessageSizeSend)
|
||||||
|
/// - k_EResultInvalidState: connection is in an invalid state
|
||||||
|
/// - k_EResultNoConnection: connection has ended
|
||||||
|
/// - k_EResultIgnored: You used k_nSteamNetworkingSend_NoDelay, and the message was dropped because
|
||||||
|
/// we were not ready to send it.
|
||||||
|
/// - k_EResultLimitExceeded: there was already too much data queued to be sent.
|
||||||
|
/// (See k_ESteamNetworkingConfig_SendBufferSize)
|
||||||
|
virtual EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, int nSendFlags ) = 0;
|
||||||
|
|
||||||
|
/// Flush any messages waiting on the Nagle timer and send them
|
||||||
|
/// at the next transmission opportunity (often that means right now).
|
||||||
|
///
|
||||||
|
/// If Nagle is enabled (it's on by default) then when calling
|
||||||
|
/// SendMessageToConnection the message will be buffered, up to the Nagle time
|
||||||
|
/// before being sent, to merge small messages into the same packet.
|
||||||
|
/// (See k_ESteamNetworkingConfig_NagleTime)
|
||||||
|
///
|
||||||
|
/// Returns:
|
||||||
|
/// k_EResultInvalidParam: invalid connection handle
|
||||||
|
/// k_EResultInvalidState: connection is in an invalid state
|
||||||
|
/// k_EResultNoConnection: connection has ended
|
||||||
|
/// k_EResultIgnored: We weren't (yet) connected, so this operation has no effect.
|
||||||
|
virtual EResult FlushMessagesOnConnection( HSteamNetConnection hConn ) = 0;
|
||||||
|
|
||||||
|
/// Fetch the next available message(s) from the connection, if any.
|
||||||
|
/// Returns the number of messages returned into your array, up to nMaxMessages.
|
||||||
|
/// If the connection handle is invalid, -1 is returned.
|
||||||
|
///
|
||||||
|
/// The order of the messages returned in the array is relevant.
|
||||||
|
/// Reliable messages will be received in the order they were sent (and with the
|
||||||
|
/// same sizes --- see SendMessageToConnection for on this subtle difference from a stream socket).
|
||||||
|
///
|
||||||
|
/// Unreliable messages may be dropped, or delivered out of order withrespect to
|
||||||
|
/// each other or with respect to reliable messages. The same unreliable message
|
||||||
|
/// may be received multiple times.
|
||||||
|
///
|
||||||
|
/// If any messages are returned, you MUST call SteamNetworkingMessage_t::Release() on each
|
||||||
|
/// of them free up resources after you are done. It is safe to keep the object alive for
|
||||||
|
/// a little while (put it into some queue, etc), and you may call Release() from any thread.
|
||||||
|
virtual int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
|
||||||
|
|
||||||
|
/// Same as ReceiveMessagesOnConnection, but will return the next message available
|
||||||
|
/// on any connection that was accepted through the specified listen socket. Examine
|
||||||
|
/// SteamNetworkingMessage_t::m_conn to know which client connection.
|
||||||
|
///
|
||||||
|
/// Delivery order of messages among different clients is not defined. They may
|
||||||
|
/// be returned in an order different from what they were actually received. (Delivery
|
||||||
|
/// order of messages from the same client is well defined, and thus the order of the
|
||||||
|
/// messages is relevant!)
|
||||||
|
virtual int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
|
||||||
|
|
||||||
|
/// Returns basic information about the high-level state of the connection.
|
||||||
|
virtual bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo ) = 0;
|
||||||
|
|
||||||
|
/// Returns a small set of information about the real-time state of the connection
|
||||||
|
/// Returns false if the connection handle is invalid, or the connection has ended.
|
||||||
|
virtual bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats ) = 0;
|
||||||
|
|
||||||
|
/// Returns detailed connection stats in text format. Useful
|
||||||
|
/// for dumping to a log, etc.
|
||||||
|
///
|
||||||
|
/// Returns:
|
||||||
|
/// -1 failure (bad connection handle)
|
||||||
|
/// 0 OK, your buffer was filled in and '\0'-terminated
|
||||||
|
/// >0 Your buffer was either nullptr, or it was too small and the text got truncated.
|
||||||
|
/// Try again with a buffer of at least N bytes.
|
||||||
|
virtual int GetDetailedConnectionStatus( HSteamNetConnection hConn, char *pszBuf, int cbBuf ) = 0;
|
||||||
|
|
||||||
|
/// Returns local IP and port that a listen socket created using CreateListenSocketIP is bound to.
|
||||||
|
///
|
||||||
|
/// An IPv6 address of ::0 means "any IPv4 or IPv6"
|
||||||
|
/// An IPv6 address of ::ffff:0000:0000 means "any IPv4"
|
||||||
|
virtual bool GetListenSocketAddress( HSteamListenSocket hSocket, SteamNetworkingIPAddr *address ) = 0;
|
||||||
|
|
||||||
|
/// Create a pair of connections that are talking to each other, e.g. a loopback connection.
|
||||||
|
/// This is very useful for testing, or so that your client/server code can work the same
|
||||||
|
/// even when you are running a local "server".
|
||||||
|
///
|
||||||
|
/// The two connections will immediately be placed into the connected state, and no callbacks
|
||||||
|
/// will be posted immediately. After this, if you close either connection, the other connection
|
||||||
|
/// will receive a callback, exactly as if they were communicating over the network. You must
|
||||||
|
/// close *both* sides in order to fully clean up the resources!
|
||||||
|
///
|
||||||
|
/// By default, internal buffers are used, completely bypassing the network, the chopping up of
|
||||||
|
/// messages into packets, encryption, copying the payload, etc. This means that loopback
|
||||||
|
/// packets, by default, will not simulate lag or loss. Passing true for bUseNetworkLoopback will
|
||||||
|
/// cause the socket pair to send packets through the local network loopback device (127.0.0.1)
|
||||||
|
/// on ephemeral ports. Fake lag and loss are supported in this case, and CPU time is expended
|
||||||
|
/// to encrypt and decrypt.
|
||||||
|
///
|
||||||
|
/// If you wish to assign a specific identity to either connection, you may pass a particular
|
||||||
|
/// identity. Otherwise, if you pass nullptr, the respective connection will assume a generic
|
||||||
|
/// "localhost" identity. If you use real network loopback, this might be translated to the
|
||||||
|
/// actual bound loopback port. Otherwise, the port will be zero.
|
||||||
|
virtual bool CreateSocketPair( HSteamNetConnection *pOutConnection1, HSteamNetConnection *pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity *pIdentity1, const SteamNetworkingIdentity *pIdentity2 ) = 0;
|
||||||
|
|
||||||
|
/// Get the identity assigned to this interface.
|
||||||
|
/// E.g. on Steam, this is the user's SteamID, or for the gameserver interface, the SteamID assigned
|
||||||
|
/// to the gameserver. Returns false and sets the result to an invalid identity if we don't know
|
||||||
|
/// our identity yet. (E.g. GameServer has not logged in. On Steam, the user will know their SteamID
|
||||||
|
/// even if they are not signed into Steam.)
|
||||||
|
virtual bool GetIdentity( SteamNetworkingIdentity *pIdentity ) = 0;
|
||||||
|
|
||||||
|
#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
||||||
|
|
||||||
|
//
|
||||||
|
// Clients connecting to dedicated servers hosted in a data center,
|
||||||
|
// using central-authority-granted tickets.
|
||||||
|
//
|
||||||
|
|
||||||
|
/// Call this when you receive a ticket from your backend / matchmaking system. Puts the
|
||||||
|
/// ticket into a persistent cache, and optionally returns the parsed ticket.
|
||||||
|
///
|
||||||
|
/// See stamdatagram_ticketgen.h for more details.
|
||||||
|
virtual bool ReceivedRelayAuthTicket( const void *pvTicket, int cbTicket, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0;
|
||||||
|
|
||||||
|
/// Search cache for a ticket to talk to the server on the specified virtual port.
|
||||||
|
/// If found, returns the number of seconds until the ticket expires, and optionally
|
||||||
|
/// the complete cracked ticket. Returns 0 if we don't have a ticket.
|
||||||
|
///
|
||||||
|
/// Typically this is useful just to confirm that you have a ticket, before you
|
||||||
|
/// call ConnectToHostedDedicatedServer to connect to the server.
|
||||||
|
virtual int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameServer, int nVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0;
|
||||||
|
|
||||||
|
/// Client call to connect to a server hosted in a Valve data center, on the specified virtual
|
||||||
|
/// port. You must have placed a ticket for this server into the cache, or else this connect attempt will fail!
|
||||||
|
///
|
||||||
|
/// You may wonder why tickets are stored in a cache, instead of simply being passed as an argument
|
||||||
|
/// here. The reason is to make reconnection to a gameserver robust, even if the client computer loses
|
||||||
|
/// connection to Steam or the central backend, or the app is restarted or crashes, etc.
|
||||||
|
///
|
||||||
|
/// If you use this, you probably want to call ISteamNetworkingUtils::InitializeRelayNetworkAccess()
|
||||||
|
/// when your app initializes
|
||||||
|
virtual HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity &identityTarget, int nVirtualPort ) = 0;
|
||||||
|
|
||||||
|
//
|
||||||
|
// Servers hosted in Valve data centers
|
||||||
|
//
|
||||||
|
|
||||||
|
/// Returns the value of the SDR_LISTEN_PORT environment variable. This
|
||||||
|
/// is the UDP server your server will be listening on. This will
|
||||||
|
/// configured automatically for you in production environments. (You
|
||||||
|
/// should set it yourself for testing.)
|
||||||
|
virtual uint16 GetHostedDedicatedServerPort() = 0;
|
||||||
|
|
||||||
|
/// If you are running in a production data center, this will return the data
|
||||||
|
/// center code. Returns 0 otherwise.
|
||||||
|
virtual SteamNetworkingPOPID GetHostedDedicatedServerPOPID() = 0;
|
||||||
|
|
||||||
|
/// Return info about the hosted server. You will need to send this information to your
|
||||||
|
/// backend, and put it in tickets, so that the relays will know how to forward traffic from
|
||||||
|
/// clients to your server. See SteamDatagramRelayAuthTicket for more info.
|
||||||
|
///
|
||||||
|
/// NOTE ABOUT DEVELOPMENT ENVIRONMENTS:
|
||||||
|
/// In production in our data centers, these parameters are configured via environment variables.
|
||||||
|
/// In development, the only one you need to set is SDR_LISTEN_PORT, which is the local port you
|
||||||
|
/// want to listen on. Furthermore, if you are running your server behind a corporate firewall,
|
||||||
|
/// you probably will not be able to put the routing information returned by this function into
|
||||||
|
/// tickets. Instead, it should be a public internet address that the relays can use to send
|
||||||
|
/// data to your server. So you might just end up hardcoding a public address and setup port
|
||||||
|
/// forwarding on your corporate firewall. In that case, the port you put into the ticket
|
||||||
|
/// needs to be the public-facing port opened on your firewall, if it is different from the
|
||||||
|
/// actual server port.
|
||||||
|
///
|
||||||
|
/// This function will fail if SteamDatagramServer_Init has not been called.
|
||||||
|
///
|
||||||
|
/// Returns false if the SDR_LISTEN_PORT environment variable is not set.
|
||||||
|
virtual bool GetHostedDedicatedServerAddress001( SteamDatagramHostedAddress *pRouting ) = 0;
|
||||||
|
|
||||||
|
/// Create a listen socket on the specified virtual port. The physical UDP port to use
|
||||||
|
/// will be determined by the SDR_LISTEN_PORT environment variable. If a UDP port is not
|
||||||
|
/// configured, this call will fail.
|
||||||
|
///
|
||||||
|
/// Note that this call MUST be made through the SteamGameServerNetworkingSockets() interface
|
||||||
|
virtual HSteamListenSocket CreateHostedDedicatedServerListenSocket( int nVirtualPort ) = 0;
|
||||||
|
|
||||||
|
#endif // #ifndef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
||||||
|
|
||||||
|
// Invoke all callbacks queued for this interface.
|
||||||
|
// On Steam, callbacks are dispatched via the ordinary Steamworks callbacks mechanism.
|
||||||
|
// So if you have code that is also targeting Steam, you should call this at about the
|
||||||
|
// same time you would call SteamAPI_RunCallbacks and SteamGameServer_RunCallbacks.
|
||||||
|
#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
|
||||||
|
virtual void RunCallbacks( ISteamNetworkingSocketsCallbacks *pCallbacks ) = 0;
|
||||||
|
#endif
|
||||||
|
protected:
|
||||||
|
// ~ISteamNetworkingSockets(); // Silence some warnings
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // ISTEAMNETWORKINGSOCKETS002
|
@ -0,0 +1,252 @@
|
|||||||
|
|
||||||
|
#ifndef ISTEAMNETWORKINGUTILS001
|
||||||
|
#define ISTEAMNETWORKINGUTILS001
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
/// Misc networking utilities for checking the local networking environment
|
||||||
|
/// and estimating pings.
|
||||||
|
class ISteamNetworkingUtils001
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
||||||
|
|
||||||
|
//
|
||||||
|
// Initialization
|
||||||
|
//
|
||||||
|
|
||||||
|
/// If you know that you are going to be using the relay network, call
|
||||||
|
/// this to initialize the relay network or check if that initialization
|
||||||
|
/// has completed. If you do not call this, the initialization will
|
||||||
|
/// happen the first time you use a feature that requires access to the
|
||||||
|
/// relay network, and that use will be delayed.
|
||||||
|
///
|
||||||
|
/// Returns true if initialization has completed successfully.
|
||||||
|
/// (It will probably return false on the first call.)
|
||||||
|
///
|
||||||
|
/// Typically initialization completes in a few seconds.
|
||||||
|
///
|
||||||
|
/// Note: dedicated servers hosted with Valve do *not* need to call
|
||||||
|
/// this, since they do not make routing decisions. However, if the
|
||||||
|
/// dedicated server will be using P2P functionality, it will act as
|
||||||
|
/// a "client" and this should be called.
|
||||||
|
inline bool InitializeRelayNetworkAccess();
|
||||||
|
|
||||||
|
//
|
||||||
|
// "Ping location" functions
|
||||||
|
//
|
||||||
|
// We use the ping times to the valve relays deployed worldwide to
|
||||||
|
// generate a "marker" that describes the location of an Internet host.
|
||||||
|
// Given two such markers, we can estimate the network latency between
|
||||||
|
// two hosts, without sending any packets. The estimate is based on the
|
||||||
|
// optimal route that is found through the Valve network. If you are
|
||||||
|
// using the Valve network to carry the traffic, then this is precisely
|
||||||
|
// the ping you want. If you are not, then the ping time will probably
|
||||||
|
// still be a reasonable estimate.
|
||||||
|
//
|
||||||
|
// This is extremely useful to select peers for matchmaking!
|
||||||
|
//
|
||||||
|
// The markers can also be converted to a string, so they can be transmitted.
|
||||||
|
// We have a separate library you can use on your backend to manipulate
|
||||||
|
// these objects. (See steamdatagram_ticketgen.h)
|
||||||
|
|
||||||
|
/// Return location info for the current host. Returns the approximate
|
||||||
|
/// age of the data, in seconds, or -1 if no data is available.
|
||||||
|
///
|
||||||
|
/// It takes a few seconds to initialize access to the relay network. If
|
||||||
|
/// you call this very soon after calling InitializeRelayNetworkAccess,
|
||||||
|
/// the data may not be available yet.
|
||||||
|
///
|
||||||
|
/// This always return the most up-to-date information we have available
|
||||||
|
/// right now, even if we are in the middle of re-calculating ping times.
|
||||||
|
virtual float GetLocalPingLocation( SteamNetworkPingLocation_t &result ) = 0;
|
||||||
|
|
||||||
|
/// Estimate the round-trip latency between two arbitrary locations, in
|
||||||
|
/// milliseconds. This is a conservative estimate, based on routing through
|
||||||
|
/// the relay network. For most basic relayed connections, this ping time
|
||||||
|
/// will be pretty accurate, since it will be based on the route likely to
|
||||||
|
/// be actually used.
|
||||||
|
///
|
||||||
|
/// If a direct IP route is used (perhaps via NAT traversal), then the route
|
||||||
|
/// will be different, and the ping time might be better. Or it might actually
|
||||||
|
/// be a bit worse! Standard IP routing is frequently suboptimal!
|
||||||
|
///
|
||||||
|
/// But even in this case, the estimate obtained using this method is a
|
||||||
|
/// reasonable upper bound on the ping time. (Also it has the advantage
|
||||||
|
/// of returning immediately and not sending any packets.)
|
||||||
|
///
|
||||||
|
/// In a few cases we might not able to estimate the route. In this case
|
||||||
|
/// a negative value is returned. k_nSteamNetworkingPing_Failed means
|
||||||
|
/// the reason was because of some networking difficulty. (Failure to
|
||||||
|
/// ping, etc) k_nSteamNetworkingPing_Unknown is returned if we cannot
|
||||||
|
/// currently answer the question for some other reason.
|
||||||
|
///
|
||||||
|
/// Do you need to be able to do this from a backend/matchmaking server?
|
||||||
|
/// You are looking for the "ticketgen" library.
|
||||||
|
virtual int EstimatePingTimeBetweenTwoLocations( const SteamNetworkPingLocation_t &location1, const SteamNetworkPingLocation_t &location2 ) = 0;
|
||||||
|
|
||||||
|
/// Same as EstimatePingTime, but assumes that one location is the local host.
|
||||||
|
/// This is a bit faster, especially if you need to calculate a bunch of
|
||||||
|
/// these in a loop to find the fastest one.
|
||||||
|
///
|
||||||
|
/// In rare cases this might return a slightly different estimate than combining
|
||||||
|
/// GetLocalPingLocation with EstimatePingTimeBetweenTwoLocations. That's because
|
||||||
|
/// this function uses a slightly more complete set of information about what
|
||||||
|
/// route would be taken.
|
||||||
|
virtual int EstimatePingTimeFromLocalHost( const SteamNetworkPingLocation_t &remoteLocation ) = 0;
|
||||||
|
|
||||||
|
/// Convert a ping location into a text format suitable for sending over the wire.
|
||||||
|
/// The format is a compact and human readable. However, it is subject to change
|
||||||
|
/// so please do not parse it yourself. Your buffer must be at least
|
||||||
|
/// k_cchMaxSteamNetworkingPingLocationString bytes.
|
||||||
|
virtual void ConvertPingLocationToString( const SteamNetworkPingLocation_t &location, char *pszBuf, int cchBufSize ) = 0;
|
||||||
|
|
||||||
|
/// Parse back SteamNetworkPingLocation_t string. Returns false if we couldn't understand
|
||||||
|
/// the string.
|
||||||
|
virtual bool ParsePingLocationString( const char *pszString, SteamNetworkPingLocation_t &result ) = 0;
|
||||||
|
|
||||||
|
//
|
||||||
|
// Initialization / ping measurement status
|
||||||
|
//
|
||||||
|
|
||||||
|
/// Check if the ping data of sufficient recency is available, and if
|
||||||
|
/// it's too old, start refreshing it.
|
||||||
|
///
|
||||||
|
/// Please only call this function when you *really* do need to force an
|
||||||
|
/// immediate refresh of the data. (For example, in response to a specific
|
||||||
|
/// user input to refresh this information.) Don't call it "just in case",
|
||||||
|
/// before every connection, etc. That will cause extra traffic to be sent
|
||||||
|
/// for no benefit. The library will automatically refresh the information
|
||||||
|
/// as needed.
|
||||||
|
///
|
||||||
|
/// Returns true if sufficiently recent data is already available.
|
||||||
|
///
|
||||||
|
/// Returns false if sufficiently recent data is not available. In this
|
||||||
|
/// case, ping measurement is initiated, if it is not already active.
|
||||||
|
/// (You cannot restart a measurement already in progress.)
|
||||||
|
virtual bool CheckPingDataUpToDate( float flMaxAgeSeconds ) = 0;
|
||||||
|
|
||||||
|
/// Return true if we are taking ping measurements to update our ping
|
||||||
|
/// location or select optimal routing. Ping measurement typically takes
|
||||||
|
/// a few seconds, perhaps up to 10 seconds.
|
||||||
|
virtual bool IsPingMeasurementInProgress() = 0;
|
||||||
|
|
||||||
|
//
|
||||||
|
// List of Valve data centers, and ping times to them. This might
|
||||||
|
// be useful to you if you are use our hosting, or just need to measure
|
||||||
|
// latency to a cloud data center where we are running relays.
|
||||||
|
//
|
||||||
|
|
||||||
|
/// Fetch ping time of best available relayed route from this host to
|
||||||
|
/// the specified data center.
|
||||||
|
virtual int GetPingToDataCenter( SteamNetworkingPOPID popID, SteamNetworkingPOPID *pViaRelayPoP ) = 0;
|
||||||
|
|
||||||
|
/// Get *direct* ping time to the relays at the data center.
|
||||||
|
virtual int GetDirectPingToPOP( SteamNetworkingPOPID popID ) = 0;
|
||||||
|
|
||||||
|
/// Get number of network points of presence in the config
|
||||||
|
virtual int GetPOPCount() = 0;
|
||||||
|
|
||||||
|
/// Get list of all POP IDs. Returns the number of entries that were filled into
|
||||||
|
/// your list.
|
||||||
|
virtual int GetPOPList( SteamNetworkingPOPID *list, int nListSz ) = 0;
|
||||||
|
#endif // #ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
|
||||||
|
|
||||||
|
//
|
||||||
|
// Misc
|
||||||
|
//
|
||||||
|
|
||||||
|
/// Fetch current timestamp. This timer has the following properties:
|
||||||
|
///
|
||||||
|
/// - Monotonicity is guaranteed.
|
||||||
|
/// - The initial value will be at least 24*3600*30*1e6, i.e. about
|
||||||
|
/// 30 days worth of microseconds. In this way, the timestamp value of
|
||||||
|
/// 0 will always be at least "30 days ago". Also, negative numbers
|
||||||
|
/// will never be returned.
|
||||||
|
/// - Wraparound / overflow is not a practical concern.
|
||||||
|
///
|
||||||
|
/// If you are running under the debugger and stop the process, the clock
|
||||||
|
/// might not advance the full wall clock time that has elapsed between
|
||||||
|
/// calls. If the process is not blocked from normal operation, the
|
||||||
|
/// timestamp values will track wall clock time, even if you don't call
|
||||||
|
/// the function frequently.
|
||||||
|
///
|
||||||
|
/// The value is only meaningful for this run of the process. Don't compare
|
||||||
|
/// it to values obtained on another computer, or other runs of the same process.
|
||||||
|
virtual SteamNetworkingMicroseconds GetLocalTimestamp() = 0;
|
||||||
|
|
||||||
|
/// Set a function to receive network-related information that is useful for debugging.
|
||||||
|
/// This can be very useful during development, but it can also be useful for troubleshooting
|
||||||
|
/// problems with tech savvy end users. If you have a console or other log that customers
|
||||||
|
/// can examine, these log messages can often be helpful to troubleshoot network issues.
|
||||||
|
/// (Especially any warning/error messages.)
|
||||||
|
///
|
||||||
|
/// The detail level indicates what message to invoke your callback on. Lower numeric
|
||||||
|
/// value means more important, and the value you pass is the lowest priority (highest
|
||||||
|
/// numeric value) you wish to receive callbacks for.
|
||||||
|
///
|
||||||
|
/// Except when debugging, you should only use k_ESteamNetworkingSocketsDebugOutputType_Msg
|
||||||
|
/// or k_ESteamNetworkingSocketsDebugOutputType_Warning. For best performance, do NOT
|
||||||
|
/// request a high detail level and then filter out messages in your callback. Instead,
|
||||||
|
/// call function function to adjust the desired level of detail.
|
||||||
|
///
|
||||||
|
/// IMPORTANT: This may be called from a service thread, while we own a mutex, etc.
|
||||||
|
/// Your output function must be threadsafe and fast! Do not make any other
|
||||||
|
/// Steamworks calls from within the handler.
|
||||||
|
virtual void SetDebugOutputFunction( ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ) = 0;
|
||||||
|
|
||||||
|
//
|
||||||
|
// Set and get configuration values, see ESteamNetworkingConfigValue for individual descriptions.
|
||||||
|
//
|
||||||
|
|
||||||
|
// Shortcuts for common cases. (Implemented as inline functions below)
|
||||||
|
bool SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val );
|
||||||
|
bool SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val );
|
||||||
|
bool SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val );
|
||||||
|
bool SetConnectionConfigValueInt32( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, int32 val );
|
||||||
|
bool SetConnectionConfigValueFloat( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, float val );
|
||||||
|
bool SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworkingConfigValue eValue, const char *val );
|
||||||
|
|
||||||
|
/// Set a configuration value.
|
||||||
|
/// - eValue: which value is being set
|
||||||
|
/// - eScope: Onto what type of object are you applying the setting?
|
||||||
|
/// - scopeArg: Which object you want to change? (Ignored for global scope). E.g. connection handle, listen socket handle, interface pointer, etc.
|
||||||
|
/// - eDataType: What type of data is in the buffer at pValue? This must match the type of the variable exactly!
|
||||||
|
/// - pArg: Value to set it to. You can pass NULL to remove a non-global sett at this scope,
|
||||||
|
/// causing the value for that object to use global defaults. Or at global scope, passing NULL
|
||||||
|
/// will reset any custom value and restore it to the system default.
|
||||||
|
/// NOTE: When setting callback functions, do not pass the function pointer directly.
|
||||||
|
/// Your argument should be a pointer to a function pointer.
|
||||||
|
virtual bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj,
|
||||||
|
ESteamNetworkingConfigDataType eDataType, const void *pArg ) = 0;
|
||||||
|
|
||||||
|
/// Get a configuration value.
|
||||||
|
/// - eValue: which value to fetch
|
||||||
|
/// - eScopeType: query setting on what type of object
|
||||||
|
/// - eScopeArg: the object to query the setting for
|
||||||
|
/// - pOutDataType: If non-NULL, the data type of the value is returned.
|
||||||
|
/// - pResult: Where to put the result. Pass NULL to query the required buffer size. (k_ESteamNetworkingGetConfigValue_BufferTooSmall will be returned.)
|
||||||
|
/// - cbResult: IN: the size of your buffer. OUT: the number of bytes filled in or required.
|
||||||
|
virtual ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj,
|
||||||
|
ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult ) = 0;
|
||||||
|
|
||||||
|
/// 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.
|
||||||
|
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;
|
||||||
|
|
||||||
|
// 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 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
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // ISTEAMNETWORKINGUTILS001
|
@ -0,0 +1,81 @@
|
|||||||
|
//============ Copyright (c) Valve Corporation, All rights reserved. ============
|
||||||
|
|
||||||
|
#ifndef ISTEAMREMOTEPLAY_H
|
||||||
|
#define ISTEAMREMOTEPLAY_H
|
||||||
|
#ifdef _WIN32
|
||||||
|
#pragma once
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include "steam_api_common.h"
|
||||||
|
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
// Purpose: The form factor of a device
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
enum ESteamDeviceFormFactor
|
||||||
|
{
|
||||||
|
k_ESteamDeviceFormFactorUnknown,
|
||||||
|
k_ESteamDeviceFormFactorPhone,
|
||||||
|
k_ESteamDeviceFormFactorTablet,
|
||||||
|
k_ESteamDeviceFormFactorComputer,
|
||||||
|
k_ESteamDeviceFormFactorTV,
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
// Purpose: Functions to provide information about Steam Remote Play sessions
|
||||||
|
//-----------------------------------------------------------------------------
|
||||||
|
class ISteamRemotePlay
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Get the number of currently connected Steam Remote Play sessions
|
||||||
|
virtual uint32 GetSessionCount() = 0;
|
||||||
|
|
||||||
|
// Get the currently connected Steam Remote Play session ID at the specified index. Returns zero if index is out of bounds.
|
||||||
|
virtual uint32 GetSessionID( int iSessionIndex ) = 0;
|
||||||
|
|
||||||
|
// Get the SteamID of the connected user
|
||||||
|
virtual CSteamID GetSessionSteamID( uint32 unSessionID ) = 0;
|
||||||
|
|
||||||
|
// Get the name of the session client device
|
||||||
|
// This returns NULL if the sessionID is not valid
|
||||||
|
virtual const char *GetSessionClientName( uint32 unSessionID ) = 0;
|
||||||
|
|
||||||
|
// Get the form factor of the session client device
|
||||||
|
virtual ESteamDeviceFormFactor GetSessionClientFormFactor( uint32 unSessionID ) = 0;
|
||||||
|
|
||||||
|
// Get the resolution, in pixels, of the session client device
|
||||||
|
// This is set to 0x0 if the resolution is not available
|
||||||
|
virtual bool BGetSessionClientResolution( uint32 unSessionID, int *pnResolutionX, int *pnResolutionY ) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION001"
|
||||||
|
|
||||||
|
// Global interface accessor
|
||||||
|
inline ISteamRemotePlay *SteamRemotePlay();
|
||||||
|
STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamRemotePlay *, SteamRemotePlay, STEAMREMOTEPLAY_INTERFACE_VERSION );
|
||||||
|
|
||||||
|
// callbacks
|
||||||
|
#if defined( VALVE_CALLBACK_PACK_SMALL )
|
||||||
|
#pragma pack( push, 4 )
|
||||||
|
#elif defined( VALVE_CALLBACK_PACK_LARGE )
|
||||||
|
#pragma pack( push, 8 )
|
||||||
|
#else
|
||||||
|
#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionConnected_t, k_iSteamRemotePlayCallbacks + 1 )
|
||||||
|
STEAM_CALLBACK_MEMBER( 0, uint32, m_unSessionID )
|
||||||
|
STEAM_CALLBACK_END( 0 )
|
||||||
|
|
||||||
|
|
||||||
|
STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionDisconnected_t, k_iSteamRemotePlayCallbacks + 2 )
|
||||||
|
STEAM_CALLBACK_MEMBER( 0, uint32, m_unSessionID )
|
||||||
|
STEAM_CALLBACK_END( 0 )
|
||||||
|
|
||||||
|
|
||||||
|
#pragma pack( pop )
|
||||||
|
|
||||||
|
|
||||||
|
#endif // #define ISTEAMREMOTEPLAY_H
|
@ -0,0 +1,162 @@
|
|||||||
|
|
||||||
|
#ifndef ISTEAMUGC012_H
|
||||||
|
#define ISTEAMUGC012_H
|
||||||
|
#ifdef STEAM_WIN32
|
||||||
|
#pragma once
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class ISteamUGC012
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
|
||||||
|
// Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
|
||||||
|
virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
|
||||||
|
|
||||||
|
// Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
|
||||||
|
virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
|
||||||
|
|
||||||
|
// Query for all matching UGC using the new deep paging interface. Creator app id or consumer app id must be valid and be set to the current running app. pchCursor should be set to NULL or "*" to get the first result set.
|
||||||
|
virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char *pchCursor = NULL ) = 0;
|
||||||
|
|
||||||
|
// Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this)
|
||||||
|
virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
|
||||||
|
|
||||||
|
// Send the query to Steam
|
||||||
|
STEAM_CALL_RESULT( SteamUGCQueryCompleted_t )
|
||||||
|
virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
|
||||||
|
|
||||||
|
// Retrieve an individual result after receiving the callback for querying UGC
|
||||||
|
virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
|
||||||
|
virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize ) = 0;
|
||||||
|
virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchMetadatasize) char *pchMetadata, uint32 cchMetadatasize ) = 0;
|
||||||
|
virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0;
|
||||||
|
virtual bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 *pStatValue ) = 0;
|
||||||
|
virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0;
|
||||||
|
virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType ) = 0;
|
||||||
|
virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0;
|
||||||
|
virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, STEAM_OUT_STRING_COUNT(cchKeySize) char *pchKey, uint32 cchKeySize, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
|
||||||
|
|
||||||
|
// Release the request to free up memory, after retrieving results
|
||||||
|
virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
|
||||||
|
|
||||||
|
// Options to set for querying UGC
|
||||||
|
virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
|
||||||
|
virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
|
||||||
|
virtual bool SetReturnOnlyIDs( UGCQueryHandle_t handle, bool bReturnOnlyIDs ) = 0;
|
||||||
|
virtual bool SetReturnKeyValueTags( UGCQueryHandle_t handle, bool bReturnKeyValueTags ) = 0;
|
||||||
|
virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
|
||||||
|
virtual bool SetReturnMetadata( UGCQueryHandle_t handle, bool bReturnMetadata ) = 0;
|
||||||
|
virtual bool SetReturnChildren( UGCQueryHandle_t handle, bool bReturnChildren ) = 0;
|
||||||
|
virtual bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ) = 0;
|
||||||
|
virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
|
||||||
|
virtual bool SetReturnPlaytimeStats( UGCQueryHandle_t handle, uint32 unDays ) = 0;
|
||||||
|
virtual bool SetLanguage( UGCQueryHandle_t handle, const char *pchLanguage ) = 0;
|
||||||
|
virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0;
|
||||||
|
|
||||||
|
// Options only for querying user UGC
|
||||||
|
virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
|
||||||
|
|
||||||
|
// Options only for querying all UGC
|
||||||
|
virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
|
||||||
|
virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
|
||||||
|
virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
|
||||||
|
virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0;
|
||||||
|
|
||||||
|
// DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!
|
||||||
|
virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0;
|
||||||
|
|
||||||
|
// Steam Workshop Creator API
|
||||||
|
STEAM_CALL_RESULT( CreateItemResult_t )
|
||||||
|
virtual SteamAPICall_t CreateItem( AppId_t nConsumerAppId, EWorkshopFileType eFileType ) = 0; // create new item for this app with no content attached yet
|
||||||
|
|
||||||
|
virtual UGCUpdateHandle_t StartItemUpdate( AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ) = 0; // start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()
|
||||||
|
|
||||||
|
virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item
|
||||||
|
virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item
|
||||||
|
virtual bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, const char *pchLanguage ) = 0; // specify the language of the title or description that will be set
|
||||||
|
virtual bool SetItemMetadata( UGCUpdateHandle_t handle, const char *pchMetaData ) = 0; // change the metadata of an UGC item (max = k_cchDeveloperMetadataMax)
|
||||||
|
virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item
|
||||||
|
virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags ) = 0; // change the tags of an UGC item
|
||||||
|
virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder
|
||||||
|
virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; // change preview image file for this item. pszPreviewFile points to local image file, which must be under 1MB in size
|
||||||
|
virtual bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, bool bAllowLegacyUpload ) = 0; // use legacy upload for a single small file. The parameter to SetItemContent() should either be a directory with one file or the full path to the file. The file must also be less than 10MB in size.
|
||||||
|
virtual bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey ) = 0; // remove any existing key-value tags with the specified key
|
||||||
|
virtual bool AddItemKeyValueTag( UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue ) = 0; // add new key-value tags for the item. Note that there can be multiple values for a tag.
|
||||||
|
virtual bool AddItemPreviewFile( UGCUpdateHandle_t handle, const char *pszPreviewFile, EItemPreviewType type ) = 0; // add preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
|
||||||
|
virtual bool AddItemPreviewVideo( UGCUpdateHandle_t handle, const char *pszVideoID ) = 0; // add preview video for this item
|
||||||
|
virtual bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile ) = 0; // updates an existing preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
|
||||||
|
virtual bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID ) = 0; // updates an existing preview video for this item
|
||||||
|
virtual bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index ) = 0; // remove a preview by index starting at 0 (previews are sorted)
|
||||||
|
|
||||||
|
STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
|
||||||
|
virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
|
||||||
|
virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0;
|
||||||
|
|
||||||
|
// Steam Workshop Consumer API
|
||||||
|
STEAM_CALL_RESULT( SetUserItemVoteResult_t )
|
||||||
|
virtual SteamAPICall_t SetUserItemVote( PublishedFileId_t nPublishedFileID, bool bVoteUp ) = 0;
|
||||||
|
STEAM_CALL_RESULT( GetUserItemVoteResult_t )
|
||||||
|
virtual SteamAPICall_t GetUserItemVote( PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
|
||||||
|
virtual SteamAPICall_t AddItemToFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
|
||||||
|
virtual SteamAPICall_t RemoveItemFromFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t )
|
||||||
|
virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscribe to this item, will be installed ASAP
|
||||||
|
STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t )
|
||||||
|
virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits
|
||||||
|
virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items
|
||||||
|
virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs
|
||||||
|
|
||||||
|
// get EItemState flags about item on this client
|
||||||
|
virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
|
||||||
|
// get info about currently installed content on disc for items that have k_EItemStateInstalled set
|
||||||
|
// if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder)
|
||||||
|
virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, STEAM_OUT_STRING_COUNT( cchFolderSize ) char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp ) = 0;
|
||||||
|
|
||||||
|
// get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once
|
||||||
|
virtual bool GetItemDownloadInfo( PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
|
||||||
|
|
||||||
|
// download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,
|
||||||
|
// then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.
|
||||||
|
// If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.
|
||||||
|
virtual bool DownloadItem( PublishedFileId_t nPublishedFileID, bool bHighPriority ) = 0;
|
||||||
|
|
||||||
|
// game servers can set a specific workshop folder before issuing any UGC commands.
|
||||||
|
// This is helpful if you want to support multiple game servers running out of the same install folder
|
||||||
|
virtual bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, const char *pszFolder ) = 0;
|
||||||
|
|
||||||
|
// SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends
|
||||||
|
virtual void SuspendDownloads( bool bSuspend ) = 0;
|
||||||
|
|
||||||
|
// usage tracking
|
||||||
|
STEAM_CALL_RESULT( StartPlaytimeTrackingResult_t )
|
||||||
|
virtual SteamAPICall_t StartPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
|
||||||
|
STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
|
||||||
|
virtual SteamAPICall_t StopPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
|
||||||
|
STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
|
||||||
|
virtual SteamAPICall_t StopPlaytimeTrackingForAllItems() = 0;
|
||||||
|
|
||||||
|
// parent-child relationship or dependency management
|
||||||
|
STEAM_CALL_RESULT( AddUGCDependencyResult_t )
|
||||||
|
virtual SteamAPICall_t AddDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
|
||||||
|
STEAM_CALL_RESULT( RemoveUGCDependencyResult_t )
|
||||||
|
virtual SteamAPICall_t RemoveDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
|
||||||
|
|
||||||
|
// add/remove app dependence/requirements (usually DLC)
|
||||||
|
STEAM_CALL_RESULT( AddAppDependencyResult_t )
|
||||||
|
virtual SteamAPICall_t AddAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
|
||||||
|
STEAM_CALL_RESULT( RemoveAppDependencyResult_t )
|
||||||
|
virtual SteamAPICall_t RemoveAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
|
||||||
|
// request app dependencies. note that whatever callback you register for GetAppDependenciesResult_t may be called multiple times
|
||||||
|
// until all app dependencies have been returned
|
||||||
|
STEAM_CALL_RESULT( GetAppDependenciesResult_t )
|
||||||
|
virtual SteamAPICall_t GetAppDependencies( PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
|
||||||
|
// delete the item without prompting the user
|
||||||
|
STEAM_CALL_RESULT( DeleteItemResult_t )
|
||||||
|
virtual SteamAPICall_t DeleteItem( PublishedFileId_t nPublishedFileID ) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // ISTEAMUGC012_H
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue