Update to latest overlay build

Updated to 1.61

dll/dll/steam_timeline.h

@@ -21,7 +21,8 @@
 #include "base.h"
 
 class Steam_Timeline :
-public ISteamTimeline
+public ISteamTimeline,
+public ISteamTimeline001
 {
 private:
     constexpr const static float PRIORITY_CLIP_MIN_SEC = 8.0f;
@@ -92,6 +93,38 @@ public:
 
     void SetTimelineGameMode( ETimelineGameMode eMode );
 
+    void SetTimelineTooltip(const char* pchDescription, float flTimeDelta);
+    void ClearTimelineTooltip(float flTimeDelta);
+    
+    TimelineEventHandle_t AddInstantaneousTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None );
+	TimelineEventHandle_t AddRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, float flDuration = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None );
+
+	TimelineEventHandle_t StartRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip );
+
+    void UpdateRangeTimelineEvent( TimelineEventHandle_t ulEvent, const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip );
+
+    void EndRangeTimelineEvent( TimelineEventHandle_t ulEvent, float flEndOffsetSeconds );
+
+    void RemoveTimelineEvent( TimelineEventHandle_t ulEvent );
+
+    SteamAPICall_t DoesEventRecordingExist( TimelineEventHandle_t ulEvent );
+
+    void StartGamePhase();
+
+    void EndGamePhase();
+
+    void SetGamePhaseID( const char *pchPhaseID );
+
+    SteamAPICall_t DoesGamePhaseRecordingExist( const char *pchPhaseID );
+
+    void AddGamePhaseTag( const char *pchTagName, const char *pchTagIcon, const char *pchTagGroup, uint32 unPriority );
+
+    void SetGamePhaseAttribute( const char *pchAttributeGroup, const char *pchAttributeValue, uint32 unPriority );
+
+    void OpenOverlayToGamePhase( const char *pchPhaseID );
+
+    void OpenOverlayToTimelineEvent( const TimelineEventHandle_t ulEvent );
+
 };
 
 #endif // __INCLUDED_STEAM_TIMELINE_H__

dll/flat.cpp

@@ -2084,6 +2084,11 @@ STEAMAPI_API steam_bool SteamAPI_ISteamRemoteStorage_EndFileWriteBatch( ISteamRe
     return (get_steam_client()->steam_remote_storage)->EndFileWriteBatch();
 }
 
+STEAMAPI_API ISteamUserStats *SteamAPI_SteamUserStats_v013()
+{
+    return get_steam_client()->GetISteamUserStats(flat_hsteamuser(), flat_hsteampipe(), "STEAMUSERSTATS_INTERFACE_VERSION013");
+}
+
 STEAMAPI_API ISteamUserStats *SteamAPI_SteamUserStats_v012()
 {
     return get_steam_client()->GetISteamUserStats(flat_hsteamuser(), flat_hsteampipe(), "STEAMUSERSTATS_INTERFACE_VERSION012");
@@ -2529,6 +2534,26 @@ STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetDlcContext( ISteamApps* self, App
     return self->SetDlcContext(nAppID);
 }
 
+// SDK 1.61 removed unAppID param
+STEAMAPI_API int SteamAPI_ISteamApps_GetNumBetas(ISteamApps* self, int* pnAvailable, int* pnPrivate)
+{
+    return self->GetNumBetas(pnAvailable, pnPrivate);
+}
+
+// SDK 1.61 removed unAppID param
+STEAMAPI_API steam_bool SteamAPI_ISteamApps_GetBetaInfo(ISteamApps* self, int iBetaIndex, uint32* punFlags, uint32* punBuildID, char* pchBetaName, int cchBetaName, char* pchDescription, int cchDescription)
+{
+    return self->GetBetaInfo(iBetaIndex, punFlags, punBuildID, pchBetaName, cchBetaName, pchDescription, cchDescription);
+}
+
+// SDK 1.61 removed unAppID param
+STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetActiveBeta(ISteamApps* self, const char* pchBetaName)
+{
+    return self->SetActiveBeta(pchBetaName);
+}
+
+/*
+//SDK 1.60
 STEAMAPI_API int SteamAPI_ISteamApps_GetNumBetas( ISteamApps* self, AppId_t unAppID, int * pnAvailable, int * pnPrivate )
 {
     // in SDK 1.60 param unAppID is unused
@@ -2552,6 +2577,7 @@ STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetActiveBeta( ISteamApps* self, App
 
     return self->SetActiveBeta(pchBetaName);
 }
+*/
 
 STEAMAPI_API ISteamNetworking *SteamAPI_SteamNetworking_v006()
 {
@@ -5481,6 +5507,11 @@ STEAMAPI_API steam_bool SteamAPI_ISteamInventory_InspectItem( ISteamInventory* s
     return (ptr)->InspectItem(pResultHandle, pchItemToken);
 }
 
+STEAMAPI_API ISteamTimeline *SteamAPI_SteamTimeline_v004()
+{
+    return get_steam_client()->GetISteamTimeline(flat_hsteamuser(), flat_hsteampipe(), "STEAMTIMELINE_INTERFACE_V004");
+}
+
 STEAMAPI_API ISteamTimeline *SteamAPI_SteamTimeline_v001()
 {
     return get_steam_client()->GetISteamTimeline(flat_hsteamuser(), flat_hsteampipe(), "STEAMTIMELINE_INTERFACE_V001");
@@ -5488,22 +5519,107 @@ STEAMAPI_API ISteamTimeline *SteamAPI_SteamTimeline_v001()
 
 STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineStateDescription( ISteamTimeline* self, const char * pchDescription, float flTimeDelta )
 {
-    return self->SetTimelineStateDescription(pchDescription, flTimeDelta);
+    return (get_steam_client()->steam_timeline)->SetTimelineStateDescription(pchDescription, flTimeDelta);
 }
 
 STEAMAPI_API void SteamAPI_ISteamTimeline_ClearTimelineStateDescription( ISteamTimeline* self, float flTimeDelta )
 {
-    return self->ClearTimelineStateDescription(flTimeDelta);
+    return (get_steam_client()->steam_timeline)->ClearTimelineStateDescription(flTimeDelta);
 }
 
 STEAMAPI_API void SteamAPI_ISteamTimeline_AddTimelineEvent( ISteamTimeline* self, const char * pchIcon, const char * pchTitle, const char * pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip )
 {
-    self->AddTimelineEvent(pchIcon, pchTitle, pchDescription, unPriority, flStartOffsetSeconds, flDurationSeconds, ePossibleClip);
+    (get_steam_client()->steam_timeline)->AddTimelineEvent(pchIcon, pchTitle, pchDescription, unPriority, flStartOffsetSeconds, flDurationSeconds, ePossibleClip);
 }
 
 STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineGameMode( ISteamTimeline* self, ETimelineGameMode eMode )
 {
-    self->SetTimelineGameMode(eMode);
+    (get_steam_client()->steam_timeline)->SetTimelineGameMode(eMode);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineTooltip(ISteamTimeline* self, const char* pchDescription, float flTimeDelta)
+{
+    (get_steam_client()->steam_timeline)->SetTimelineTooltip(pchDescription, flTimeDelta);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_ClearTimelineTooltip(ISteamTimeline* self, float flTimeDelta)
+{
+    return (get_steam_client()->steam_timeline)->ClearTimelineTooltip(flTimeDelta);
+}
+
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent(ISteamTimeline* self, const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip)
+{
+    return (get_steam_client()->steam_timeline)->AddInstantaneousTimelineEvent(pchTitle, pchDescription, pchIcon, unIconPriority, flStartOffsetSeconds, ePossibleClip);
+}
+
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddRangeTimelineEvent(ISteamTimeline* self, const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, float flDuration, ETimelineEventClipPriority ePossibleClip)
+{
+    return (get_steam_client()->steam_timeline)->AddRangeTimelineEvent(pchTitle, pchDescription, pchIcon, unIconPriority, flStartOffsetSeconds, flDuration, ePossibleClip);
+}
+
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_StartRangeTimelineEvent(ISteamTimeline* self, const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip)
+{
+    return (get_steam_client()->steam_timeline)->StartRangeTimelineEvent(pchTitle, pchDescription, pchIcon, unPriority, flStartOffsetSeconds, ePossibleClip);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent(ISteamTimeline* self, TimelineEventHandle_t ulEvent, const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip)
+{
+    return (get_steam_client()->steam_timeline)->UpdateRangeTimelineEvent(ulEvent, pchTitle, pchDescription, pchIcon, unPriority, ePossibleClip);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_EndRangeTimelineEvent(ISteamTimeline* self, TimelineEventHandle_t ulEvent, float flEndOffsetSeconds)
+{
+    return (get_steam_client()->steam_timeline)->EndRangeTimelineEvent(ulEvent, flEndOffsetSeconds);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_RemoveTimelineEvent(ISteamTimeline* self, TimelineEventHandle_t ulEvent)
+{
+    return (get_steam_client()->steam_timeline)->RemoveTimelineEvent(ulEvent);
+}
+
+STEAMAPI_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesEventRecordingExist(ISteamTimeline* self, TimelineEventHandle_t ulEvent)
+{
+    return (get_steam_client()->steam_timeline)->DoesEventRecordingExist(ulEvent);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_StartGamePhase(ISteamTimeline* self)
+{
+    return (get_steam_client()->steam_timeline)->StartGamePhase();
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_EndGamePhase(ISteamTimeline* self)
+{
+    return (get_steam_client()->steam_timeline)->EndGamePhase();
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetGamePhaseID(ISteamTimeline* self, const char* pchPhaseID)
+{
+    return (get_steam_client()->steam_timeline)->SetGamePhaseID(pchPhaseID);
+}
+
+STEAMAPI_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist(ISteamTimeline* self, const char* pchPhaseID)
+{
+    return (get_steam_client()->steam_timeline)->DoesGamePhaseRecordingExist(pchPhaseID);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_AddGamePhaseTag(ISteamTimeline* self, const char* pchTagName, const char* pchTagIcon, const char* pchTagGroup, uint32 unPriority)
+{
+    return (get_steam_client()->steam_timeline)->AddGamePhaseTag(pchTagName, pchTagIcon, pchTagGroup, unPriority);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetGamePhaseAttribute(ISteamTimeline* self, const char* pchAttributeGroup, const char* pchAttributeValue, uint32 unPriority)
+{
+    return (get_steam_client()->steam_timeline)->SetGamePhaseAttribute(pchAttributeGroup, pchAttributeValue, unPriority);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_OpenOverlayToGamePhase(ISteamTimeline* self, const char* pchPhaseID)
+{
+    return (get_steam_client()->steam_timeline)->OpenOverlayToGamePhase(pchPhaseID);
+}
+
+STEAMAPI_API void SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent(ISteamTimeline* self, const TimelineEventHandle_t ulEvent)
+{
+    return (get_steam_client()->steam_timeline)->OpenOverlayToTimelineEvent(ulEvent);
 }
 
 STEAMAPI_API ISteamVideo *SteamAPI_SteamVideo_v001()

dll/steam_client_interface_getter.cpp

@@ -37,7 +37,10 @@ ISteamTimeline *Steam_Client::GetISteamTimeline( HSteamUser hSteamUser, HSteamPi
     PRINT_DEBUG("%s", pchVersion);
     if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return nullptr;
 
-    if (strcmp(pchVersion, STEAMTIMELINE_INTERFACE_VERSION) == 0) {
+    if (strcmp(pchVersion, "STEAMTIMELINE_INTERFACE_VERSION001") == 0) {
+        return reinterpret_cast<ISteamTimeline *>(static_cast<ISteamTimeline001 *>(steam_timeline));
+    }
+    else if (strcmp(pchVersion, STEAMTIMELINE_INTERFACE_VERSION) == 0) {
         return reinterpret_cast<ISteamTimeline *>(static_cast<ISteamTimeline *>(steam_timeline));
     }
 
@@ -485,6 +488,8 @@ ISteamUserStats *Steam_Client::GetISteamUserStats( HSteamUser hSteamUser, HSteam
         return reinterpret_cast<ISteamUserStats *>(static_cast<ISteamUserStats010 *>(steam_user_stats));
     } else if (strcmp(pchVersion, "STEAMUSERSTATS_INTERFACE_VERSION011") == 0) {
         return reinterpret_cast<ISteamUserStats *>(static_cast<ISteamUserStats011 *>(steam_user_stats));
+    } else if (strcmp(pchVersion, "STEAMUSERSTATS_INTERFACE_VERSION012") == 0) {
+        return reinterpret_cast<ISteamUserStats *>(static_cast<ISteamUserStats *>(steam_user_stats));
     } else if (strcmp(pchVersion, STEAMUSERSTATS_INTERFACE_VERSION) == 0) {
         return reinterpret_cast<ISteamUserStats *>(static_cast<ISteamUserStats *>(steam_user_stats));
     }

dll/steam_timeline.cpp

@@ -177,6 +177,90 @@ void Steam_Timeline::SetTimelineGameMode( ETimelineGameMode eMode )
     new_timeline_state.bar_color = eMode;
 }
 
+void Steam_Timeline::SetTimelineTooltip(const char* pchDescription, float flTimeDelta)
+{
+    SetTimelineStateDescription(pchDescription, flTimeDelta);
+}
+
+void Steam_Timeline::ClearTimelineTooltip(float flTimeDelta)
+{
+    ClearTimelineStateDescription(flTimeDelta);
+}
+
+TimelineEventHandle_t Steam_Timeline::AddInstantaneousTimelineEvent(const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip)
+{
+    return 0;
+}
+
+TimelineEventHandle_t Steam_Timeline::AddRangeTimelineEvent(const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, float flDuration, ETimelineEventClipPriority ePossibleClip)
+{
+    return 0;
+}
+
+TimelineEventHandle_t Steam_Timeline::StartRangeTimelineEvent(const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip)
+{
+    return 0;
+}
+
+void Steam_Timeline::UpdateRangeTimelineEvent(TimelineEventHandle_t ulEvent, const char* pchTitle, const char* pchDescription, const char* pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip)
+{
+
+}
+
+void Steam_Timeline::EndRangeTimelineEvent(TimelineEventHandle_t ulEvent, float flEndOffsetSeconds)
+{
+
+}
+
+void Steam_Timeline::RemoveTimelineEvent(TimelineEventHandle_t ulEvent)
+{
+
+}
+
+SteamAPICall_t Steam_Timeline::DoesEventRecordingExist(TimelineEventHandle_t ulEvent)
+{
+    return 0;
+}
+
+void Steam_Timeline::StartGamePhase()
+{
+
+}
+
+void Steam_Timeline::EndGamePhase()
+{
+
+}
+
+void Steam_Timeline::SetGamePhaseID(const char* pchPhaseID)
+{
+
+}
+
+SteamAPICall_t Steam_Timeline::DoesGamePhaseRecordingExist(const char* pchPhaseID)
+{
+    return 0;
+}
+
+void Steam_Timeline::AddGamePhaseTag(const char* pchTagName, const char* pchTagIcon, const char* pchTagGroup, uint32 unPriority)
+{
+
+}
+
+void Steam_Timeline::SetGamePhaseAttribute(const char* pchAttributeGroup, const char* pchAttributeValue, uint32 unPriority)
+{
+
+}
+
+void Steam_Timeline::OpenOverlayToGamePhase(const char* pchPhaseID)
+{
+
+}
+
+void Steam_Timeline::OpenOverlayToTimelineEvent(const TimelineEventHandle_t ulEvent)
+{
+
+}
 
 
 void Steam_Timeline::RunCallbacks()

overlay_experimental/overlay/steam_overlay.h

@@ -71,8 +71,8 @@ struct Overlay_Achievement
     bool hidden{};
     bool achieved{};
     uint32 unlock_time{};
-    std::weak_ptr<uint64_t> icon{};
+    InGameOverlay::RendererResource_t* icon{};
-    std::weak_ptr<uint64_t> icon_gray{};
+    InGameOverlay::RendererResource_t* icon_gray{};
     int icon_handle = Settings::UNLOADED_IMAGE_HANDLE;
     int icon_gray_handle = Settings::UNLOADED_IMAGE_HANDLE;
 };

overlay_experimental/steam_overlay.cpp

@@ -32,7 +32,7 @@ static constexpr int base_notif_window_id  = 0 * max_window_id;
 static constexpr int base_friend_window_id = 1 * max_window_id;
 static constexpr int base_friend_item_id   = 2 * max_window_id;
 
-static const std::set<InGameOverlay::ToggleKey> overlay_toggle_keys = {
+static const InGameOverlay::ToggleKey overlay_toggle_keys[] overlay_toggle_keys = {
     InGameOverlay::ToggleKey::SHIFT, InGameOverlay::ToggleKey::TAB
 };
 
@@ -203,7 +203,7 @@ bool Steam_Overlay::renderer_hook_proc()
         PRINT_DEBUG("renderer hook was null!");
         return true;
     }
-    PRINT_DEBUG("got renderer hook %p for '%s'", _renderer, _renderer->GetLibraryName().c_str());
+    PRINT_DEBUG("got renderer hook %p for '%s'", _renderer, _renderer->GetLibraryName());
     
     // note: make sure to load all relevant strings before creating the font(s), otherwise some glyphs ranges will be missing
     load_achievements_data();
@@ -218,7 +218,7 @@ bool Steam_Overlay::renderer_hook_proc()
         overlay_state_hook(state == InGameOverlay::OverlayHookState::Ready || state == InGameOverlay::OverlayHookState::Reset);
     };
 
-    bool started = _renderer->StartHook(overlay_toggle_callback, overlay_toggle_keys, &fonts_atlas);
+    bool started = _renderer->StartHook(overlay_toggle_callback, overlay_toggle_keys, 2, &fonts_atlas);
     PRINT_DEBUG("started renderer hook (result=%i)", (int)started);
     
     return true;
@@ -362,6 +362,13 @@ void Steam_Overlay::load_achievements_data()
             ach.max_progress = (uint32)pnMaxProgress;
         }
 
+        if (ach.icon == nullptr) {
+            ach.icon = _renderer->CreateResource();
+        }
+        if (ach.icon_gray == nullptr) {
+            ach.icon_gray = _renderer->CreateResource();
+        }
+
         achievements.emplace_back(ach);
         
         if (!setup_overlay_called) return;
@@ -1057,13 +1064,13 @@ void Steam_Overlay::build_notifications(float width, float height)
                     auto &icon_rsrc = (notification_type)it->type == notification_type::achievement
                         ? ach.icon
                         : ach.icon_gray;
-                    if (!icon_rsrc.expired() && ImGui::BeginTable("imgui_table", 2)) {
+                    if (icon_rsrc->GetResourceId() != 0 && ImGui::BeginTable("imgui_table", 2)) {
                         ImGui::TableSetupColumn("imgui_table_image", ImGuiTableColumnFlags_WidthFixed, settings->overlay_appearance.icon_size);
                         ImGui::TableSetupColumn("imgui_table_text");
                         ImGui::TableNextRow(ImGuiTableRowFlags_None, settings->overlay_appearance.icon_size);
 
                         ImGui::TableSetColumnIndex(0);
-                        ImGui::Image((ImTextureID)*icon_rsrc.lock().get(), ImVec2(settings->overlay_appearance.icon_size, settings->overlay_appearance.icon_size));
+                        ImGui::Image(icon_rsrc->GetResourceId(), ImVec2(settings->overlay_appearance.icon_size, settings->overlay_appearance.icon_size));
 
                         ImGui::TableSetColumnIndex(1);
                         ImGui::TextWrapped("%s", it->message.c_str());
@@ -1208,7 +1215,7 @@ bool Steam_Overlay::try_load_ach_icon(Overlay_Achievement &ach, bool achieved, b
     if (!settings->overlay_upload_achs_icons_to_gpu) return false; // don't upload anything to the GPU
 
     auto &icon_rsrc = achieved ? ach.icon : ach.icon_gray;
-    if (!icon_rsrc.expired()) return true;
+    if (icon_rsrc->GetResourceId() != 0) return true;
 
     // icons needs to be loaded, but we're not allowed
     if (!upload_new_icon_to_gpu) return false;
@@ -1220,14 +1227,13 @@ bool Steam_Overlay::try_load_ach_icon(Overlay_Achievement &ach, bool achieved, b
     auto image_info = settings->get_image(icon_handle);
     if (image_info) {
         int icon_size = static_cast<int>(settings->overlay_appearance.icon_size);
-        icon_rsrc = _renderer->CreateImageResource(
+        icon_rsrc->SetAutoLoad(InGameOverlay::ResourceAutoLoad_t::OnUse);
-            (void*)image_info->data.c_str(),
+        icon_rsrc->AttachResource((void*)image_info->data.c_str(), icon_size, icon_size);
-            icon_size, icon_size);
         
-        PRINT_DEBUG("'%s' (result=%i)", ach.name.c_str(), (int)!icon_rsrc.expired());
+        PRINT_DEBUG("'%s' (result=%i)", ach.name.c_str(), (int)icon_rsrc->GetResourceId() != 0);
     }
 
-    return !icon_rsrc.expired();
+    return icon_rsrc->GetResourceId() != 0;
 }
 
 // Try to make this function as short as possible or it might affect game's fps.
@@ -1325,7 +1331,7 @@ uint32 Steam_Overlay::apply_global_style_color()
 void Steam_Overlay::render_main_window()
 {
     char tmp[TRANSLATION_BUFFER_SIZE]{};
-    snprintf(tmp, sizeof(tmp), translationRenderer[current_language], (_renderer == nullptr ? "Unknown" : _renderer->GetLibraryName().c_str()));
+    snprintf(tmp, sizeof(tmp), translationRenderer[current_language], (_renderer == nullptr ? "Unknown" : _renderer->GetLibraryName()));
     std::string windowTitle{};
     // Note: don't translate this, project and author names are nouns, they must be kept intact for proper referral
     // think of it as translating "Protobuf - Google"
@@ -1432,7 +1438,7 @@ void Steam_Overlay::render_main_window()
                     ImGui::Separator();
 
                     bool could_create_ach_table_entry = false;
-                    if (!x.icon.expired() || !x.icon_gray.expired()) {
+                    if (x.icon->GetResourceId() != 0 || x.icon_gray->GetResourceId() != 0) {
                         if (ImGui::BeginTable(x.title.c_str(), 2)) {
                             could_create_ach_table_entry = true;
 
@@ -1442,9 +1448,9 @@ void Steam_Overlay::render_main_window()
 
                             ImGui::TableSetColumnIndex(0);
                             auto &icon_rsrc = achieved ? x.icon : x.icon_gray;
-                            if (!icon_rsrc.expired()) {
+                            if (icon_rsrc->GetResourceId() != 0)) {
                                 ImGui::Image(
-                                    (ImTextureID)*icon_rsrc.lock().get(),
+                                    icon_rsrc->GetResourceId(),
                                     ImVec2(settings->overlay_appearance.icon_size, settings->overlay_appearance.icon_size)
                                 );
                             }
@@ -1667,14 +1673,12 @@ void Steam_Overlay::UnSetupOverlay()
             
             PRINT_DEBUG("releasing any images resources");
             for (auto &ach : achievements) {
-                if (!ach.icon.expired()) {
+                if (ach.icon->GetResourceId() != 0) {
-                    _renderer->ReleaseImageResource(ach.icon);
+                    ach.icon->Unload();
-                    ach.icon.reset();
                 }
 
-                if (!ach.icon_gray.expired()) {
+                if (ach.icon_gray->GetResourceId() != 0) {
-                    _renderer->ReleaseImageResource(ach.icon_gray);
+                    ach.icon_gray->Unload();
-                    ach.icon_gray.reset();
                 }
             }
 

premake5-deps.lua

@@ -697,6 +697,8 @@ if _OPTIONS["build-ingame_overlay"] or _OPTIONS["all-build"] then
         'INGAMEOVERLAY_USE_SYSTEM_LIBRARIES=OFF',
         'INGAMEOVERLAY_USE_SPDLOG=OFF',
         'INGAMEOVERLAY_BUILD_TESTS=OFF',
+        'INGAMEOVERLAY_DYNAMIC_RUNTIME=OFF',
+        --'USE_MSVC_RUNTIME_LIBRARY_DLL=OFF', -- Should we?
     }
     -- fix missing standard include/header file for gcc/clang
     local ingame_overlay_fixes = {}
@@ -713,19 +715,23 @@ if _OPTIONS["build-ingame_overlay"] or _OPTIONS["all-build"] then
 
     if _OPTIONS["32-build"] then
         cmake_build('ingame_overlay/deps/System', true, {
-            'BUILD_SYSTEMLIB_TESTS=OFF',
+            'SYSTEM_BUILD_TESTS=OFF',
+            'SYSTEM_DYNAMIC_RUNTIME=OFF',
         }, nil, ingame_overlay_fixes)
         cmake_build('ingame_overlay/deps/mini_detour', true, {
-            'BUILD_MINIDETOUR_TESTS=OFF',
+            'MINIDETOUR_BUILD_TESTS=OFF',
+            'MINIDETOUR_DYNAMIC_RUNTIME=OFF',
         })
         cmake_build('ingame_overlay', true, ingame_overlay_common_defs, nil, ingame_overlay_fixes)
     end
     if _OPTIONS["64-build"] then
         cmake_build('ingame_overlay/deps/System', false, {
-            'BUILD_SYSTEMLIB_TESTS=OFF',
+            'SYSTEM_BUILD_TESTS=OFF',
+            'SYSTEM_DYNAMIC_RUNTIME=OFF',
         }, nil, ingame_overlay_fixes)
         cmake_build('ingame_overlay/deps/mini_detour', false, {
-            'BUILD_MINIDETOUR_TESTS=OFF',
+            'MINIDETOUR_BUILD_TESTS=OFF',
+            'MINIDETOUR_DYNAMIC_RUNTIME=OFF',
         })
         cmake_build('ingame_overlay', false, ingame_overlay_common_defs, nil, ingame_overlay_fixes)
     end

sdk/steam/isteamcontroller.h

@@ -501,6 +501,11 @@ enum EControllerActionOrigin
 	k_EControllerActionOrigin_PS5_LeftFn,
 	k_EControllerActionOrigin_PS5_RightFn,
 
+	k_EControllerActionOrigin_Horipad_M1,
+	k_EControllerActionOrigin_Horipad_M2,
+	k_EControllerActionOrigin_Horipad_L4,
+	k_EControllerActionOrigin_Horipad_R4,
+
 	k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };

sdk/steam/isteamfriends.h

@@ -765,6 +765,7 @@ struct EquippedProfileItems_t
 	bool m_bHasProfileModifier;
 	bool m_bHasProfileBackground;
 	bool m_bHasMiniProfileBackground;
+	bool m_bFromCache;
 };
 
 #pragma pack( pop )

sdk/steam/isteaminput.h

@@ -504,6 +504,11 @@ enum EInputActionOrigin
 	k_EInputActionOrigin_SteamDeck_Reserved19,
 	k_EInputActionOrigin_SteamDeck_Reserved20,
 
+	k_EInputActionOrigin_Horipad_M1,
+	k_EInputActionOrigin_Horipad_M2,
+	k_EInputActionOrigin_Horipad_L4,
+	k_EInputActionOrigin_Horipad_R4,
+
 	k_EInputActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EInputActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };

sdk/steam/isteamtimeline.h

@@ -48,7 +48,11 @@ enum ETimelineEventClipPriority
 };
 
 const uint32 k_unMaxTimelinePriority = 1000;
+const uint32 k_unTimelinePriority_KeepCurrentValue = 1000000; // Use with UpdateRangeTimelineEvent to not change the priority
 const float k_flMaxTimelineEventDuration = 600.f;
+const uint32 k_cchMaxPhaseIDLength = 64;
+
+typedef uint64 TimelineEventHandle_t;
 
 //-----------------------------------------------------------------------------
 // Purpose: Steam Timeline API
@@ -60,52 +64,166 @@ public:
 	// Sets a description for the current game state in the timeline. These help the user to find specific
 	// moments in the timeline when saving clips. Setting a new state description replaces any previous
 	// description.
-	// 
+	//
 	// Examples could include:
 	//  * Where the user is in the world in a single player game
 	//  * Which round is happening in a multiplayer game
 	//  * The current score for a sports game
-	// 	
+	//
 	// Parameters:
 	// - pchDescription: provide a localized string in the language returned by SteamUtils()->GetSteamUILanguage()
-	// - flTimeDelta: The time offset in seconds to apply to this event. Negative times indicate an 
+	// - flTimeDelta: The time offset in seconds to apply to this event. Negative times indicate an
 	//			event that happened in the past.
-	virtual void SetTimelineStateDescription( const char *pchDescription, float flTimeDelta ) = 0;
-	virtual void ClearTimelineStateDescription( float flTimeDelta ) = 0;
 
-	// Use this to mark an event on the Timeline. The event can be instantaneous or take some amount of time
+
-	// to complete, depending on the value passed in flDurationSeconds
+
-	// 
+	virtual void SetTimelineTooltip( const char *pchDescription, float flTimeDelta ) = 0;
-	// Examples could include:
+	virtual void ClearTimelineTooltip( float flTimeDelta ) = 0;
+
+	// Changes the color of the timeline bar. See ETimelineGameMode comments for how to use each value
+	virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0;
+
+	/*******************    Timeline Events    *******************/
+
+	// The following functions add events and/or tags to the timeline.  There are helpers to add simple events or tags in a single call.
+	// or you can use StartEvent and CloseEvent to customize what gets added.
+	//
+	// Examples of events to add could include:
 	//   * a boss battle
 	//   * a cut scene
 	//   * a large team fight
 	//   * picking up a new weapon or ammunition
 	//   * scoring a goal
-	// 	
+	//
-	// Parameters:
+	// Adding an event and a time range with the simple API:
-	// 
+	//   SteamTimeline()->AddSimpleTimelineEvent( "steam_heart", Localize( "#user healed" ), Localize( "#health_amount", 27 ), 15, 0, 0, k_ETimelineEventClipPriority_None );
+	//   SteamTimeline()->AddTaggedTimeRange( Localize( "#player_resting" ), "steam_flag", /* don't show filter */nullptr, 15, /* start now */0, 10 );
+	//   SteamTimeline()->AddTaggedTimeRange( Localize( "#player_cast_light" ), "steam_starburst", Localize( "#player_spells" ), 10, /* start 10 sec ago */ -10, 5 );
+	//
+	// Adding a marker and time range in one event:
+	//   TimelineEventHandle_t event = SteamTimeline()->StartEvent( /* start now */ 0 );
+	//   SteamTimeline()->ShowEventOnTimeline( event, "steam_heart", Localize( "#player_healed" ), Localize( "#player_healed_amount", 27 ), 15 );
+	//   SteamTimeline()->AddEventTag( event, Localize( "#player_cast_heal" ), "steam_heart", Localize( "#player_, 15, /* start now */0, 10 );
+	//   ... // time passes
+	//   SteamTimeline()->CloseEvent( event );
+	//
+	// Parameters used by the event functions:
+	//
+	// - ulOpenEvent: An event returned by StartEvent that has not yet had CancelEvent or CloseEvent called on it
+	// - ulEvent: An event that has had CloseEvent called on it, or an event returned from AddSimpleTimelineEvent or AddTaggedTimeRange (which
+	//   are closed automatically.)
 	// - pchIcon: specify the name of the icon uploaded through the Steamworks Partner Site for your title
 	//   or one of the provided icons that start with steam_
 	// - pchTitle & pchDescription: provide a localized string in the language returned by
 	//	 SteamUtils()->GetSteamUILanguage()
-	// - unPriority: specify how important this range is compared to other markers provided by the game. 
+	// - unIconPriority: specify how important this range is compared to other markers provided by the game.
 	//   Ranges with larger priority values will be displayed more prominently in the UI. This value
 	//   may be between 0 and k_unMaxTimelinePriority.
-	// - flStartOffsetSeconds: The time that this range started relative to now. Negative times 
+	// - flStartOffsetSeconds: The time that this range started relative to now. Negative times
 	//   indicate an event that happened in the past.
 	// - flDurationSeconds: How long the time range should be in seconds. For instantaneous events, this
 	//   should be 0
 	// - ePossibleClip: By setting this parameter to Featured or Standard, the game indicates to Steam that it
 	//   would be appropriate to offer this range as a clip to the user. For instantaneous events, the
 	//   suggested clip will be for a short time before and after the event itself.
-	virtual void AddTimelineEvent( const char *pchIcon, const char *pchTitle, const char *pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip ) = 0;
+	// - pchTagIcon: specify an icon name that will be used next to the tag name in the UI
+	// - pchTagName: The localized name of the tag to show in the UI.
+	// - pchTagGroup: The localized name of the tag group to show in the UI. If this is not specified, users will not be able to filter by this tag
+	// - unTagPriority: specify how important this tag is compared to other tags provided by the game.
+	// Returns:
+	//   A TimelineEventHandle_t that can be used to make subsequent calls to refer to the timeline event. This event handle is invalid
+	//   after the game exits.
 
-	// Changes the color of the timeline bar. See ETimelineGameMode comments for how to use each value
+	// quick helpers that add to the timeline in one call
-	virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0;
+	virtual TimelineEventHandle_t AddInstantaneousTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None ) = 0;
+	virtual TimelineEventHandle_t AddRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, float flDuration = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None ) = 0;
+
+	// Starts a timeline event at a the current time, plus an offset in seconds. This event must be ended with EndRangeTimelineEvent.
+	// Any timeline events that have not been ended when the game exits will be discarded.
+	virtual TimelineEventHandle_t StartRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip ) = 0;
+
+	// Updates fields on a range timeline event that was started with StartRangeTimelineEvent, and which has not been ended.
+	virtual void UpdateRangeTimelineEvent( TimelineEventHandle_t ulEvent, const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip ) = 0;
+
+	// Ends a range timeline event and shows it in the UI.
+	virtual void EndRangeTimelineEvent( TimelineEventHandle_t ulEvent, float flEndOffsetSeconds ) = 0;
+
+	// delete the event from the timeline. This can be called on a timeline event from AddInstantaneousTimelineEvent,
+	// AddRangeTimelineEvent, or StartRangeTimelineEvent/EndRangeTimelineEvent. The timeline event handle must be from the
+	// current game process.
+	virtual void RemoveTimelineEvent( TimelineEventHandle_t ulEvent ) = 0;
+
+	// add a tag to whatever time range is represented by the event
+	STEAM_CALL_RESULT( SteamTimelineEventRecordingExists_t )
+	virtual SteamAPICall_t DoesEventRecordingExist( TimelineEventHandle_t ulEvent ) = 0;
+
+	/*******************    Game Phases    *******************/
+
+	// Game phases allow the user to navigate their background recordings and clips. Exactly what a game phase means will vary game to game, but
+	// the game phase should be a section of gameplay that is usually between 10 minutes and a few hours in length, and should be the
+	// main way a user would think to divide up the game. These are presented to the user in a UI that shows the date the game was played,
+	// with one row per game slice. Game phases should be used to mark sections of gameplay that the user might be interested in watching.
+	//
+	//	Examples could include:
+	//		* A single match in a multiplayer PvP game
+	//		* A chapter of a story-based singleplayer game
+	//		* A single run in a roguelike
+	//
+	// Game phases are started with StartGamePhase, and while a phase is still happening, they can have tags and attributes added to them.
+	//
+	// Phase attributes represent generic text fields that can be updated throughout the duration of the phase. They are meant
+	// to be used for phase metadata that is not part of a well defined set of options. For example, a KDA attribute that starts
+	// with the value "0/0/0" and updates as the phase progresses, or something like a played-entered character name. Attributes
+	// can be set as many times as the game likes with SetGamePhaseAttribute, and only the last value will be shown to the user.
+	//
+	// Phase tags represent data with a well defined set of options, which could be data such as match resolution, hero played,
+	// game mode, etc. Tags can have an icon in addition to a text name. Multiple tags within the same group may be added per phase
+	// and all will be remembered. For example, AddGamePhaseTag may be called multiple times for a "Bosses Defeated" group, with
+	// different names and icons for each boss defeated during the phase, all of which will be shown to the user.
+	//
+	// The phase will continue until the game exits, until the game calls EndGamePhase, or until the game calls
+	// StartGamePhase to start a new phase.
+	//
+	// The game phase functions take these parameters:
+	// - pchTagIcon: The name of a game provided timeline icon or builtin "steam_" icon.
+	// - pchPhaseID: A game-provided persistent ID for a game phase. This could be a the match ID in a multiplayer game, a chapter name in a
+	//   single player game, the ID of a character, etc.
+	// - pchTagName: The localized name of the tag in the language returned by SteamUtils()->GetSteamUILanguage().
+	// - pchTagGroup: The localized name of the tag group.
+	// - pchAttributeValue: The localized name of the attribute.
+	// - pchAttributeGroup: The localized name of the attribute group.
+	// - unPriority: Used to order tags and attributes in the UI displayed to the user, with higher priority values leading
+	//   to more prominent positioning. In contexts where there is limited space, lower priority items may be hidden.
+	virtual void StartGamePhase() = 0;
+	virtual void EndGamePhase() = 0;
+
+	// Games can set a phase ID so they can refer back to a phase in OpenOverlayToPhase
+	virtual void SetGamePhaseID( const char *pchPhaseID ) = 0;
+	STEAM_CALL_RESULT( SteamTimelineGamePhaseRecordingExists_t )
+	virtual SteamAPICall_t DoesGamePhaseRecordingExist( const char *pchPhaseID ) = 0;
+
+	// Add a tag that applies to the entire phase
+	virtual void AddGamePhaseTag( const char *pchTagName, const char *pchTagIcon, const char *pchTagGroup, uint32 unPriority ) = 0;
+
+	// Add a text attribute that applies to the entire phase
+	virtual void SetGamePhaseAttribute( const char *pchAttributeGroup, const char *pchAttributeValue, uint32 unPriority ) = 0;
+
+	/*******************    Opening the overlay    *******************/
+
+	// Opens the Steam overlay to a game phase.
+	//
+	// Parameters:
+	// - pchPhaseID: The ID of a phase that was previously provided by the game in SetGamePhaseID.
+	virtual void OpenOverlayToGamePhase( const char *pchPhaseID ) = 0;
+
+	// Opens the Steam overlay to a timeline event.
+	//
+	// Parameters:
+	// - ulEventID: The ID of a timeline event returned by StartEvent or AddSimpleTimelineEvent
+	virtual void OpenOverlayToTimelineEvent( const TimelineEventHandle_t ulEvent ) = 0;
 };
 
-#define STEAMTIMELINE_INTERFACE_VERSION "STEAMTIMELINE_INTERFACE_V001"
+#define STEAMTIMELINE_INTERFACE_VERSION "STEAMTIMELINE_INTERFACE_V004"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor
@@ -113,6 +231,28 @@ inline ISteamTimeline *SteamTimeline();
 STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamTimeline *, SteamTimeline, STEAMTIMELINE_INTERFACE_VERSION );
 #endif
 
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamTimelineGamePhaseRecordingExists_t
+{
+	enum { k_iCallback = k_iSteamTimelineCallbacks + 1 };
+	char m_rgchPhaseID[ k_cchMaxPhaseIDLength ];
+	uint64 m_ulRecordingMS;
+	uint64 m_ulLongestClipMS;
+	uint32 m_unClipCount;
+	uint32 m_unScreenshotCount;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamTimelineEventRecordingExists_t
+{
+	enum { k_iCallback = k_iSteamTimelineCallbacks + 2 };
+	uint64 m_ulEventID;
+	bool m_bRecordingExists;
+};
 
 #pragma pack( pop )
 

sdk/steam/isteamtimeline001.h

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

sdk/steam/isteamuserstats.h

@@ -89,6 +89,10 @@ class ISteamUserStats
 {
 public:
 	// Ask the server to send down this user's data and achievements for this game
+	// On V013:
+	// Note: this call is no longer required as it is managed by the Steam client
+	// The game stats and achievements will be synchronized with Steam before
+	// the game process begins.
 	STEAM_CALL_BACK( UserStatsReceived_t )
 	virtual bool RequestCurrentStats() = 0;
 
@@ -211,7 +215,7 @@ public:
 	// if a user doesn't have a leaderboard entry, they won't be included in the result
 	// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
 	STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
-	STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
+	STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
 	virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
 															   STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) = 0;
 
@@ -304,7 +308,7 @@ public:
 
 };
 
-#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION012"
+#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION013"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor

sdk/steam/isteamvideo.h

@@ -48,8 +48,9 @@ inline ISteamVideo *SteamVideo();
 STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamVideo *, SteamVideo, STEAMVIDEO_INTERFACE_VERSION );
 #endif
 
-STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iClientVideoCallbacks + 4 )
+STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iSteamVideoCallbacks + 4 )
-STEAM_CALLBACK_END(0)
+	STEAM_CALLBACK_MEMBER( 0, bool, m_bIsRTMP )
+STEAM_CALLBACK_END( 1 )
 
 STEAM_CALLBACK_BEGIN( BroadcastUploadStop_t, k_iClientVideoCallbacks + 5 )
 	STEAM_CALLBACK_MEMBER( 0, EBroadcastUploadResult, m_eResult )

sdk/steam/steam_api.h

@@ -192,6 +192,7 @@
 #include "isteaminventory001.h"
 #include "isteaminventory002.h"
 #include "isteamtimeline.h"
+#include "isteamtimeline001.h"
 #include "isteamvideo.h"
 #include "isteamvideo001.h"
 #include "isteamvideo002.h"

sdk/steam/steam_api_flat.h

@@ -401,6 +401,8 @@ STEAMAPI_API steam_bool SteamAPI_ISteamRemoteStorage_EndFileWriteBatch( ISteamRe
 
 
 // ISteamUserStats
+
+STEAMAPI_API ISteamUserStats *SteamAPI_SteamUserStats_v013();
 STEAMAPI_API ISteamUserStats *SteamAPI_SteamUserStats_v012();
 STEAMAPI_API ISteamUserStats *SteamAPI_SteamUserStats_v011();
 STEAMAPI_API steam_bool SteamAPI_ISteamUserStats_RequestCurrentStats( ISteamUserStats* self );
@@ -482,9 +484,9 @@ STEAMAPI_API int SteamAPI_ISteamApps_GetLaunchCommandLine( ISteamApps* self, cha
 STEAMAPI_API steam_bool SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing( ISteamApps* self );
 STEAMAPI_API steam_bool SteamAPI_ISteamApps_BIsTimedTrial( ISteamApps* self, uint32 * punSecondsAllowed, uint32 * punSecondsPlayed );
 STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetDlcContext( ISteamApps* self, AppId_t nAppID );
-STEAMAPI_API int SteamAPI_ISteamApps_GetNumBetas( ISteamApps* self, AppId_t unAppID, int * pnAvailable, int * pnPrivate );
+STEAMAPI_API int SteamAPI_ISteamApps_GetNumBetas( ISteamApps* self, int * pnAvailable, int * pnPrivate );
-STEAMAPI_API steam_bool SteamAPI_ISteamApps_GetBetaInfo( ISteamApps* self, AppId_t unAppID, int iBetaIndex, uint32 * punFlags, uint32 * punBuildID, char * pchBetaName, int cchBetaName, char * pchDescription, int cchDescription );
+STEAMAPI_API steam_bool SteamAPI_ISteamApps_GetBetaInfo( ISteamApps* self, int iBetaIndex, uint32 * punFlags, uint32 * punBuildID, char * pchBetaName, int cchBetaName, char * pchDescription, int cchDescription );
-STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetActiveBeta( ISteamApps* self, AppId_t unAppID, const char * pchBetaName );
+STEAMAPI_API steam_bool SteamAPI_ISteamApps_SetActiveBeta( ISteamApps* self, const char * pchBetaName );
 
 
 // ISteamNetworking
@@ -898,12 +900,29 @@ STEAMAPI_API steam_bool SteamAPI_ISteamInventory_InspectItem( ISteamInventory* s
 // ISteamTimeline
 
 // A versioned accessor is exported by the library
+STEAMAPI_API ISteamTimeline *SteamAPI_SteamTimeline_v004();
 STEAMAPI_API ISteamTimeline *SteamAPI_SteamTimeline_v001();
 STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineStateDescription( ISteamTimeline* self, const char * pchDescription, float flTimeDelta );
 STEAMAPI_API void SteamAPI_ISteamTimeline_ClearTimelineStateDescription( ISteamTimeline* self, float flTimeDelta );
 STEAMAPI_API void SteamAPI_ISteamTimeline_AddTimelineEvent( ISteamTimeline* self, const char * pchIcon, const char * pchTitle, const char * pchDescription, uint32 unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip );
 STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineGameMode( ISteamTimeline* self, ETimelineGameMode eMode );
-
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetTimelineTooltip( ISteamTimeline* self, const char * pchDescription, float flTimeDelta );
+STEAMAPI_API void SteamAPI_ISteamTimeline_ClearTimelineTooltip( ISteamTimeline* self, float flTimeDelta );
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip );
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddRangeTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, float flDuration, ETimelineEventClipPriority ePossibleClip );
+STEAMAPI_API TimelineEventHandle_t SteamAPI_ISteamTimeline_StartRangeTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip );
+STEAMAPI_API void SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip );
+STEAMAPI_API void SteamAPI_ISteamTimeline_EndRangeTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent, float flEndOffsetSeconds );
+STEAMAPI_API void SteamAPI_ISteamTimeline_RemoveTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent );
+STEAMAPI_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesEventRecordingExist( ISteamTimeline* self, TimelineEventHandle_t ulEvent );
+STEAMAPI_API void SteamAPI_ISteamTimeline_StartGamePhase( ISteamTimeline* self );
+STEAMAPI_API void SteamAPI_ISteamTimeline_EndGamePhase( ISteamTimeline* self );
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetGamePhaseID( ISteamTimeline* self, const char * pchPhaseID );
+STEAMAPI_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist( ISteamTimeline* self, const char * pchPhaseID );
+STEAMAPI_API void SteamAPI_ISteamTimeline_AddGamePhaseTag( ISteamTimeline* self, const char * pchTagName, const char * pchTagIcon, const char * pchTagGroup, uint32 unPriority );
+STEAMAPI_API void SteamAPI_ISteamTimeline_SetGamePhaseAttribute( ISteamTimeline* self, const char * pchAttributeGroup, const char * pchAttributeValue, uint32 unPriority );
+STEAMAPI_API void SteamAPI_ISteamTimeline_OpenOverlayToGamePhase( ISteamTimeline* self, const char * pchPhaseID );
+STEAMAPI_API void SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent( ISteamTimeline* self, const TimelineEventHandle_t ulEvent );
 
 // ISteamVideo
 STEAMAPI_API ISteamVideo *SteamAPI_SteamVideo_v001();

sdk/steam/steamclientpublic.h

@@ -155,6 +155,7 @@ enum EResult
 	K_EResultPhoneNumberIsVOIP = 127,			// The phone number provided is a Voice Over IP number
 	k_EResultNotSupported = 128,				// The data being accessed is not supported by this API
 	k_EResultFamilySizeLimitExceeded = 129,		// Reached the maximum size of the family
+	k_EResultOfflineAppCacheInvalid = 130,		// The local data for the offline mode cache is insufficient to login
 };
 
 // Error codes for use with the voice functions