// This file is provided under The MIT License as part of Steamworks.NET. // Copyright (c) 2013-2022 Riley Labrecque // Please see the included LICENSE.txt for additional information. // This file is automatically generated. // Changes to this file will be reverted when you update Steamworks.NET #if !(UNITY_STANDALONE_WIN || UNITY_STANDALONE_LINUX || UNITY_STANDALONE_OSX || STEAMWORKS_WIN || STEAMWORKS_LIN_OSX) #define DISABLESTEAMWORKS #endif #if !DISABLESTEAMWORKS using System.Runtime.InteropServices; using IntPtr = System.IntPtr; namespace Steamworks { // friend game played information [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct FriendGameInfo_t { public CGameID m_gameID; public uint m_unGameIP; public ushort m_usGamePort; public ushort m_usQueryPort; public CSteamID m_steamIDLobby; } [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct InputAnalogActionData_t { // Type of data coming from this action, this will match what got specified in the action set public EInputSourceMode eMode; // The current state of this action; will be delta updates for mouse actions public float x, y; // Whether or not this action is currently available to be bound in the active action set public byte bActive; } [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct InputDigitalActionData_t { // The current state of this action; will be true if currently pressed public byte bState; // Whether or not this action is currently available to be bound in the active action set public byte bActive; } [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct InputMotionData_t { // Sensor-fused absolute rotation; will drift in heading toward average public float rotQuatX; public float rotQuatY; public float rotQuatZ; public float rotQuatW; // Positional acceleration public float posAccelX; public float posAccelY; public float posAccelZ; // Angular velocity public float rotVelX; public float rotVelY; public float rotVelZ; } [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct InputMotionDataV2_t { // // Gyro post processing: // // Drift Corrected Quaternion is calculated after steam input controller calibration values have been applied. // Rawest _useful_ version of a quaternion. // Most camera implementations should use this by comparing last rotation against current rotation, and applying the difference to the in game camera (plus your own sensitivity tweaks) // It is worth viewing public float driftCorrectedQuatX; public float driftCorrectedQuatY; public float driftCorrectedQuatZ; public float driftCorrectedQuatW; // Sensor fusion corrects using accelerometer, and "average forward over time" for "forward". // This can "ouija" your aim, so it's not so appropriate for camera controls (sensor fusion was originally made for racing game steering ) // Same result as from old InputMotionData_t::rotQuatX/Y/Z/W public float sensorFusionQuatX; public float sensorFusionQuatY; public float sensorFusionQuatZ; public float sensorFusionQuatW; // Deferred Sensor fusion quaternion with deferred correction // Reduces perception of "ouija" effect by only applying correction when the controller is below "low noise" thresholds, // while the controller rotates fast - never when the user is attempting precision aim. public float deferredSensorFusionQuatX; public float deferredSensorFusionQuatY; public float deferredSensorFusionQuatZ; public float deferredSensorFusionQuatW; // Same as accel but values are calibrated such that 1 unit = 1G. // X = Right // Y = Forward out through the joystick USB port. // Z = Up through the joystick axis. public float gravityX; public float gravityY; public float gravityZ; // // Same as rotVel values in GetMotionData but values are calibrated to degrees per second. // Local Space (controller relative) // X = Pitch = left to right axis // Y = Roll = axis through charging port // Z = Yaw = axis through sticks public float degreesPerSecondX; public float degreesPerSecondY; public float degreesPerSecondZ; } [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamItemDetails_t { public SteamItemInstanceID_t m_itemId; public SteamItemDef_t m_iDefinition; public ushort m_unQuantity; public ushort m_unFlags; // see ESteamItemFlags } [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamPartyBeaconLocation_t { public ESteamPartyBeaconLocationType m_eType; public ulong m_ulLocationID; } // connection state to a specified user, returned by GetP2PSessionState() // this is under-the-hood info about what's going on with a SendP2PPacket(), shouldn't be needed except for debuggin [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct P2PSessionState_t { public byte m_bConnectionActive; // true if we've got an active open connection public byte m_bConnecting; // true if we're currently trying to establish a connection public byte m_eP2PSessionError; // last error recorded (see enum above) public byte m_bUsingRelay; // true if it's going through a relay server (TURN) public int m_nBytesQueuedForSend; public int m_nPacketsQueuedForSend; public uint m_nRemoteIP; // potential IP:Port of remote host. Could be TURN server. public ushort m_nRemotePort; // Only exists for compatibility with older authentication api's } //----------------------------------------------------------------------------- // Purpose: Structure that contains an array of const char * strings and the number of those strings //----------------------------------------------------------------------------- [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamParamStringArray_t { public IntPtr m_ppStrings; public int m_nNumStrings; } // Details for a single published file/UGC [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamUGCDetails_t { public PublishedFileId_t m_nPublishedFileId; public EResult m_eResult; // The result of the operation. public EWorkshopFileType m_eFileType; // Type of the file public AppId_t m_nCreatorAppID; // ID of the app that created this file. public AppId_t m_nConsumerAppID; // ID of the app that will consume this file. [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchPublishedDocumentTitleMax)] private byte[] m_rgchTitle_; public string m_rgchTitle // title of document { get { return InteropHelp.ByteArrayToStringUTF8(m_rgchTitle_); } set { InteropHelp.StringToByteArrayUTF8(value, m_rgchTitle_, Constants.k_cchPublishedDocumentTitleMax); } } [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchPublishedDocumentDescriptionMax)] private byte[] m_rgchDescription_; public string m_rgchDescription // description of document { get { return InteropHelp.ByteArrayToStringUTF8(m_rgchDescription_); } set { InteropHelp.StringToByteArrayUTF8(value, m_rgchDescription_, Constants.k_cchPublishedDocumentDescriptionMax); } } public ulong m_ulSteamIDOwner; // Steam ID of the user who created this content. public uint m_rtimeCreated; // time when the published file was created public uint m_rtimeUpdated; // time when the published file was last updated public uint m_rtimeAddedToUserList; // time when the user added the published file to their list (not always applicable) public ERemoteStoragePublishedFileVisibility m_eVisibility; // visibility [MarshalAs(UnmanagedType.I1)] public bool m_bBanned; // whether the file was banned [MarshalAs(UnmanagedType.I1)] public bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop [MarshalAs(UnmanagedType.I1)] public bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchTagListMax)] private byte[] m_rgchTags_; public string m_rgchTags // comma separated list of all tags associated with this file { get { return InteropHelp.ByteArrayToStringUTF8(m_rgchTags_); } set { InteropHelp.StringToByteArrayUTF8(value, m_rgchTags_, Constants.k_cchTagListMax); } } // file/url information public UGCHandle_t m_hFile; // The handle of the primary file public UGCHandle_t m_hPreviewFile; // The handle of the preview file [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchFilenameMax)] private byte[] m_pchFileName_; public string m_pchFileName // The cloud filename of the primary file { get { return InteropHelp.ByteArrayToStringUTF8(m_pchFileName_); } set { InteropHelp.StringToByteArrayUTF8(value, m_pchFileName_, Constants.k_cchFilenameMax); } } public int m_nFileSize; // Size of the primary file public int m_nPreviewFileSize; // Size of the preview file [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchPublishedFileURLMax)] private byte[] m_rgchURL_; public string m_rgchURL // URL (for a video or a website) { get { return InteropHelp.ByteArrayToStringUTF8(m_rgchURL_); } set { InteropHelp.StringToByteArrayUTF8(value, m_rgchURL_, Constants.k_cchPublishedFileURLMax); } } // voting information public uint m_unVotesUp; // number of votes up public uint m_unVotesDown; // number of votes down public float m_flScore; // calculated score // collection details public uint m_unNumChildren; } // a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry() [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct LeaderboardEntry_t { public CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info public int m_nGlobalRank; // [1..N], where N is the number of users with an entry in the leaderboard public int m_nScore; // score as set in the leaderboard public int m_cDetails; // number of int32 details available for this entry public UGCHandle_t m_hUGC; // handle for UGC attached to the entry } /// Store key/value pair used in matchmaking queries. /// /// Actually, the name Key/Value is a bit misleading. The "key" is better /// understood as "filter operation code" and the "value" is the operand to this /// filter operation. The meaning of the operand depends upon the filter. [StructLayout(LayoutKind.Sequential)] public struct MatchMakingKeyValuePair_t { MatchMakingKeyValuePair_t(string strKey, string strValue) { m_szKey = strKey; m_szValue = strValue; } [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string m_szKey; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string m_szValue; } // structure that contains client callback data // see callbacks documentation for more details /// Internal structure used in manual callback dispatch [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct CallbackMsg_t { public int m_hSteamUser; // Specific user to whom this callback applies. public int m_iCallback; // Callback identifier. (Corresponds to the k_iCallback enum in the callback structure.) public IntPtr m_pubParam; // Points to the callback structure public int m_cubParam; // Size of the data pointed to by m_pubParam } /// Describe the state of a connection. [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamNetConnectionInfo_t { /// Who is on the other end? Depending on the connection type and phase of the connection, we might not know public SteamNetworkingIdentity m_identityRemote; /// Arbitrary user data set by the local application code public long m_nUserData; /// Handle to listen socket this was connected on, or k_HSteamListenSocket_Invalid if we initiated the connection public HSteamListenSocket m_hListenSocket; /// Remote address. Might be all 0's if we don't know it, or if this is N/A. /// (E.g. Basically everything except direct UDP connection.) public SteamNetworkingIPAddr m_addrRemote; public ushort m__pad1; /// What data center is the remote host in? (0 if we don't know.) public SteamNetworkingPOPID m_idPOPRemote; /// What relay are we using to communicate with the remote host? /// (0 if not applicable.) public SteamNetworkingPOPID m_idPOPRelay; /// High level state of the connection public ESteamNetworkingConnectionState m_eState; /// Basic cause of the connection termination or problem. /// See ESteamNetConnectionEnd for the values used public int m_eEndReason; /// Human-readable, but non-localized explanation for connection /// termination or problem. This is intended for debugging / /// diagnostic purposes only, not to display to users. It might /// have some details specific to the issue. [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchSteamNetworkingMaxConnectionCloseReason)] private byte[] m_szEndDebug_; public string m_szEndDebug { get { return InteropHelp.ByteArrayToStringUTF8(m_szEndDebug_); } set { InteropHelp.StringToByteArrayUTF8(value, m_szEndDebug_, Constants.k_cchSteamNetworkingMaxConnectionCloseReason); } } /// Debug description. This includes the internal connection ID, /// connection type (and peer information), and any name /// given to the connection by the app. This string is used in various /// internal logging messages. /// /// Note that the connection ID *usually* matches the HSteamNetConnection /// handle, but in certain cases with symmetric connections it might not. [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cchSteamNetworkingMaxConnectionDescription)] private byte[] m_szConnectionDescription_; public string m_szConnectionDescription { get { return InteropHelp.ByteArrayToStringUTF8(m_szConnectionDescription_); } set { InteropHelp.StringToByteArrayUTF8(value, m_szConnectionDescription_, Constants.k_cchSteamNetworkingMaxConnectionDescription); } } /// Misc flags. Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx public int m_nFlags; /// Internal stuff, room to change API easily [MarshalAs(UnmanagedType.ByValArray, SizeConst = 63)] public uint[] reserved; } /// Quick connection state, pared down to something you could call /// more frequently without it being too big of a perf hit. [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamNetConnectionRealTimeStatus_t { /// High level state of the connection public ESteamNetworkingConnectionState m_eState; /// Current ping (ms) public int m_nPing; /// Connection quality measured locally, 0...1. (Percentage of packets delivered /// end-to-end in order). public float m_flConnectionQualityLocal; /// Packet delivery success rate as observed from remote host public float m_flConnectionQualityRemote; /// Current data rates from recent history. public float m_flOutPacketsPerSec; public float m_flOutBytesPerSec; public float m_flInPacketsPerSec; public float m_flInBytesPerSec; /// Estimate rate that we believe that we can send data to our peer. /// Note that this could be significantly higher than m_flOutBytesPerSec, /// meaning the capacity of the channel is higher than you are sending data. /// (That's OK!) public int m_nSendRateBytesPerSecond; /// Number of bytes pending to be sent. This is data that you have recently /// requested to be sent but has not yet actually been put on the wire. The /// reliable number ALSO includes data that was previously placed on the wire, /// but has now been scheduled for re-transmission. Thus, it's possible to /// observe m_cbPendingReliable increasing between two checks, even if no /// calls were made to send reliable data between the checks. Data that is /// awaiting the Nagle delay will appear in these numbers. public int m_cbPendingUnreliable; public int m_cbPendingReliable; /// Number of bytes of reliable data that has been placed the wire, but /// for which we have not yet received an acknowledgment, and thus we may /// have to re-transmit. public int m_cbSentUnackedReliable; /// If you queued a message right now, approximately how long would that message /// wait in the queue before we actually started putting its data on the wire in /// a packet? /// /// In general, data that is sent by the application is limited by the bandwidth /// of the channel. If you send data faster than this, it must be queued and /// put on the wire at a metered rate. Even sending a small amount of data (e.g. /// a few MTU, say ~3k) will require some of the data to be delayed a bit. /// /// Ignoring multiple lanes, the estimated delay will be approximately equal to /// /// ( m_cbPendingUnreliable+m_cbPendingReliable ) / m_nSendRateBytesPerSecond /// /// plus or minus one MTU. It depends on how much time has elapsed since the last /// packet was put on the wire. For example, the queue might have *just* been emptied, /// and the last packet placed on the wire, and we are exactly up against the send /// rate limit. In that case we might need to wait for one packet's worth of time to /// elapse before we can send again. On the other extreme, the queue might have data /// in it waiting for Nagle. (This will always be less than one packet, because as /// soon as we have a complete packet we would send it.) In that case, we might be /// ready to send data now, and this value will be 0. /// /// This value is only valid if multiple lanes are not used. If multiple lanes are /// in use, then the queue time will be different for each lane, and you must use /// the value in SteamNetConnectionRealTimeLaneStatus_t. /// /// Nagle delay is ignored for the purposes of this calculation. public SteamNetworkingMicroseconds m_usecQueueTime; // Internal stuff, room to change API easily [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public uint[] reserved; } /// Quick status of a particular lane [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamNetConnectionRealTimeLaneStatus_t { // Counters for this particular lane. See the corresponding variables // in SteamNetConnectionRealTimeStatus_t public int m_cbPendingUnreliable; public int m_cbPendingReliable; public int m_cbSentUnackedReliable; public 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. public SteamNetworkingMicroseconds m_usecQueueTime; // Internal stuff, room to change API easily [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] public uint[] reserved; } // // Ping location / measurement // /// Object that describes a "location" on the Internet with sufficient /// detail that we can reasonably estimate an upper bound on the ping between /// the two hosts, even if a direct route between the hosts is not possible, /// and the connection must be routed through the Steam Datagram Relay network. /// This does not contain any information that identifies the host. Indeed, /// if two hosts are in the same building or otherwise have nearly identical /// networking characteristics, then it's valid to use the same location /// object for both of them. /// /// NOTE: This object should only be used in the same process! Do not serialize it, /// send it over the wire, or persist it in a file or database! If you need /// to do that, convert it to a string representation using the methods in /// ISteamNetworkingUtils(). [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] public struct SteamNetworkPingLocation_t { [MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)] public byte[] m_data; } } #endif // !DISABLESTEAMWORKS