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