802 lines
30 KiB
C++
802 lines
30 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Delegates/Delegate.h"
|
|
#include "Input/CursorReply.h"
|
|
#include "Input/Reply.h"
|
|
#include "Layout/Geometry.h"
|
|
#include "Styling/SlateTypes.h"
|
|
#include "Templates/Function.h"
|
|
#include "Widgets/DeclarativeSyntaxSupport.h"
|
|
#include "Widgets/SCompoundWidget.h"
|
|
#include "Widgets/SWidget.h"
|
|
|
|
// TraceInsightsCore
|
|
#include "InsightsCore/Common/FixedCircularBuffer.h"
|
|
|
|
// TraceInsights
|
|
#include "Insights/Config.h"
|
|
#include "Insights/ITimingViewSession.h"
|
|
#include "Insights/TimingProfiler/ViewModels/TimerNode.h"
|
|
#include "Insights/ViewModels/BaseTimingTrack.h"
|
|
#include "Insights/ViewModels/TimingEvent.h"
|
|
#include "Insights/ViewModels/TimingEventsTrack.h"
|
|
#include "Insights/ViewModels/TimingTrackViewport.h"
|
|
#include "Insights/ViewModels/TimingViewDrawHelper.h"
|
|
#include "Insights/ViewModels/TooltipDrawState.h"
|
|
|
|
#if UE_INSIGHTS_BACKWARD_COMPATIBILITY_UE54
|
|
#include "Insights/ITimingViewExtender.h"
|
|
#endif
|
|
|
|
class FMenuBuilder;
|
|
class FUICommandList;
|
|
class SDockTab;
|
|
class SOverlay;
|
|
class SScrollBar;
|
|
class FSpawnTabArgs;
|
|
|
|
namespace Insights
|
|
{
|
|
class FQuickFind;
|
|
class SQuickFind;
|
|
}
|
|
|
|
namespace UE::Insights
|
|
{
|
|
class FFilterConfigurator;
|
|
enum class ETimingEventsColoringMode : uint32;
|
|
class SLogView;
|
|
}
|
|
|
|
namespace UE::Insights::Timing
|
|
{
|
|
class ITimingViewExtender;
|
|
}
|
|
|
|
class FTimingGraphTrack;
|
|
class FTimingViewDrawHelper;
|
|
|
|
namespace UE::Insights::LoadingProfiler
|
|
{
|
|
class FLoadingSharedState;
|
|
}
|
|
|
|
namespace UE::Insights::TimingProfiler
|
|
{
|
|
|
|
class FFrameSharedState;
|
|
class FThreadTimingSharedState;
|
|
class FTimingRegionsSharedState;
|
|
class FFileActivitySharedState;
|
|
|
|
class FTimeRulerTrack;
|
|
class FTimeMarker;
|
|
class FMarkersTimingTrack;
|
|
|
|
class STimersView;
|
|
|
|
enum class ESelectEventType : uint32
|
|
{
|
|
Min = 0,
|
|
Max = 1
|
|
};
|
|
|
|
/** A custom widget used to display timing events. */
|
|
class STimingView : public SCompoundWidget, public UE::Insights::Timing::ITimingViewSession
|
|
{
|
|
public:
|
|
/** Default constructor. */
|
|
STimingView();
|
|
|
|
/** Virtual destructor. */
|
|
virtual ~STimingView();
|
|
|
|
SLATE_BEGIN_ARGS(STimingView)
|
|
{
|
|
_Clipping = EWidgetClipping::ClipToBounds;
|
|
}
|
|
SLATE_END_ARGS()
|
|
|
|
/**
|
|
* Construct this widget
|
|
*
|
|
* @param InArgs The declaration data for this widget
|
|
*/
|
|
void Construct(const FArguments& InArgs, FName InViewName = NAME_None);
|
|
|
|
/** Gets the name of the view. */
|
|
virtual const FName& GetName() const { return ViewName; }
|
|
|
|
bool IsCompactModeEnabled() const;
|
|
void ToggleCompactMode();
|
|
|
|
bool IsAutoHideEmptyTracksEnabled() const;
|
|
void ToggleAutoHideEmptyTracks();
|
|
|
|
bool IsPanningOnScreenEdgesEnabled() const;
|
|
void TogglePanningOnScreenEdges();
|
|
|
|
bool QuickFind_CanExecute() const;
|
|
void QuickFind_Execute();
|
|
|
|
bool ToggleTrackVisibility_IsChecked(uint64 InTrackId) const;
|
|
void ToggleTrackVisibility_Execute(uint64 InTrackId);
|
|
|
|
TSharedPtr<FFrameSharedState> GetFrameSharedState() const { return FrameSharedState; }
|
|
TSharedPtr<FThreadTimingSharedState> GetThreadTimingSharedState() const { return ThreadTimingSharedState; }
|
|
TSharedPtr<LoadingProfiler::FLoadingSharedState> GetLoadingSharedState() const { return LoadingSharedState; }
|
|
TSharedPtr<FFileActivitySharedState> GetFileActivitySharedState() const { return FileActivitySharedState; }
|
|
|
|
void HideAllDefaultTracks();
|
|
|
|
/** Gets the time ruler track. It includes the custom time markers (ones user can drag with mouse). */
|
|
TSharedRef<FTimeRulerTrack> GetTimeRulerTrack() { return TimeRulerTrack; }
|
|
const TSharedRef<const FTimeRulerTrack> GetTimeRulerTrack() const { return TimeRulerTrack; }
|
|
|
|
/** Gets the default (custom) time marker (for backward compatibility). */
|
|
TSharedRef<FTimeMarker> GetDefaultTimeMarker() { return DefaultTimeMarker; }
|
|
const TSharedRef<const FTimeMarker> GetDefaultTimeMarker() const { return DefaultTimeMarker; }
|
|
|
|
/** Resets internal widget's data to the default one. */
|
|
void Reset(bool bIsFirstReset = false);
|
|
|
|
/**
|
|
* Ticks this widget. Override in derived classes, but always call the parent implementation.
|
|
*
|
|
* @param AllottedGeometry The space allotted for this widget
|
|
* @param InCurrentTime Current absolute real time
|
|
* @param InDeltaTime Real time passed since last tick
|
|
*/
|
|
virtual void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime) override;
|
|
|
|
virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
|
|
|
|
/**
|
|
* The system calls this method to notify the widget that a mouse button was pressed within it. This event is bubbled.
|
|
*
|
|
* @param MyGeometry The Geometry of the widget receiving the event
|
|
* @param MouseEvent Information about the input event
|
|
*
|
|
* @return Whether the event was handled along with possible requests for the system to take action.
|
|
*/
|
|
virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* The system calls this method to notify the widget that a mouse button was release within it. This event is bubbled.
|
|
*
|
|
* @param MyGeometry The Geometry of the widget receiving the event
|
|
* @param MouseEvent Information about the input event
|
|
*
|
|
* @return Whether the event was handled along with possible requests for the system to take action.
|
|
*/
|
|
virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* Called when a mouse button is double clicked. Override this in derived classes.
|
|
*
|
|
* @param InMyGeometry Widget geometry
|
|
* @param InMouseEvent Mouse button event
|
|
*
|
|
* @return Returns whether the event was handled, along with other possible actions
|
|
*/
|
|
virtual FReply OnMouseButtonDoubleClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* The system calls this method to notify the widget that a mouse moved within it. This event is bubbled.
|
|
*
|
|
* @param MyGeometry The Geometry of the widget receiving the event
|
|
* @param MouseEvent Information about the input event
|
|
*
|
|
* @return Whether the event was handled along with possible requests for the system to take action.
|
|
*/
|
|
virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* The system will use this event to notify a widget that the cursor has entered it. This event is NOT bubbled.
|
|
*
|
|
* @param MyGeometry The Geometry of the widget receiving the event
|
|
* @param MouseEvent Information about the input event
|
|
*/
|
|
virtual void OnMouseEnter(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* The system will use this event to notify a widget that the cursor has left it. This event is NOT bubbled.
|
|
*
|
|
* @param MouseEvent Information about the input event
|
|
*/
|
|
virtual void OnMouseLeave(const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* Called when the mouse wheel is spun. This event is bubbled.
|
|
*
|
|
* @param MouseEvent Mouse event
|
|
*
|
|
* @return Returns whether the event was handled, along with other possible actions
|
|
*/
|
|
virtual FReply OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) override;
|
|
|
|
/**
|
|
* Called when the user is dropping something onto a widget; terminates drag and drop.
|
|
*
|
|
* @param MyGeometry The geometry of the widget receiving the event.
|
|
* @param DragDropEvent The drag and drop event.
|
|
*
|
|
* @return A reply that indicated whether this event was handled.
|
|
*/
|
|
virtual FReply OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
|
|
|
|
/**
|
|
* Called during drag and drop when the drag enters a widget.
|
|
*
|
|
* Enter/Leave events in slate are meant as lightweight notifications.
|
|
* So we do not want to capture mouse or set focus in response to these.
|
|
* However, OnDragEnter must also support external APIs (e.g. OLE Drag/Drop)
|
|
* Those require that we let them know whether we can handle the content
|
|
* being dragged OnDragEnter.
|
|
*
|
|
* The concession is to return a can_handled/cannot_handle
|
|
* boolean rather than a full FReply.
|
|
*
|
|
* @param MyGeometry The geometry of the widget receiving the event.
|
|
* @param DragDropEvent The drag and drop event.
|
|
*
|
|
* @return A reply that indicated whether the contents of the DragDropEvent can potentially be processed by this widget.
|
|
*/
|
|
virtual void OnDragEnter(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
|
|
|
|
/**
|
|
* Called during drag and drop when the drag leaves a widget.
|
|
*
|
|
* @param DragDropEvent The drag and drop event.
|
|
*/
|
|
virtual void OnDragLeave(const FDragDropEvent& DragDropEvent) override;
|
|
|
|
/**
|
|
* Called during drag and drop when the mouse is being dragged over a widget.
|
|
*
|
|
* @param MyGeometry The geometry of the widget receiving the event.
|
|
* @param DragDropEvent The drag and drop event.
|
|
*
|
|
* @return A reply that indicated whether this event was handled.
|
|
*/
|
|
virtual FReply OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent) override;
|
|
|
|
/**
|
|
* Called when the system wants to know which cursor to display for this Widget. This event is bubbled.
|
|
*
|
|
* @return The cursor requested (can be None.)
|
|
*/
|
|
virtual FCursorReply OnCursorQuery(const FGeometry& MyGeometry, const FPointerEvent& CursorEvent) const override;
|
|
|
|
virtual bool SupportsKeyboardFocus() const override { return true; }
|
|
virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
|
|
virtual FReply OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// ITimingViewSession interface
|
|
|
|
virtual void AddTopDockedTrack(TSharedPtr<FBaseTimingTrack> Track) override { AddTrack(Track, ETimingTrackLocation::TopDocked); }
|
|
virtual bool RemoveTopDockedTrack(TSharedPtr<FBaseTimingTrack> Track) override { return RemoveTrack(Track); }
|
|
|
|
virtual void AddBottomDockedTrack(TSharedPtr<FBaseTimingTrack> Track) override { AddTrack(Track, ETimingTrackLocation::BottomDocked); }
|
|
virtual bool RemoveBottomDockedTrack(TSharedPtr<FBaseTimingTrack> Track) override { return RemoveTrack(Track); }
|
|
|
|
virtual void AddScrollableTrack(TSharedPtr<FBaseTimingTrack> Track) override { AddTrack(Track, ETimingTrackLocation::Scrollable); }
|
|
virtual bool RemoveScrollableTrack(TSharedPtr<FBaseTimingTrack> Track) override { return RemoveTrack(Track); }
|
|
virtual void InvalidateScrollableTracksOrder() override;
|
|
|
|
virtual void AddForegroundTrack(TSharedPtr<FBaseTimingTrack> Track) override { AddTrack(Track, ETimingTrackLocation::Foreground); }
|
|
virtual bool RemoveForegroundTrack(TSharedPtr<FBaseTimingTrack> Track) override { return RemoveTrack(Track); }
|
|
|
|
virtual void AddTrack(TSharedPtr<FBaseTimingTrack> Track, ETimingTrackLocation Location) override;
|
|
virtual bool RemoveTrack(TSharedPtr<FBaseTimingTrack> Track) override;
|
|
|
|
virtual TSharedPtr<FBaseTimingTrack> FindTrack(uint64 InTrackId) override;
|
|
virtual void EnumerateTracks(TFunctionRef<void(TSharedPtr<FBaseTimingTrack> Track)> Callback) override;
|
|
|
|
virtual double GetTimeMarker() const override;
|
|
virtual void SetTimeMarker(double InTimeMarker) override;
|
|
virtual void SetAndCenterOnTimeMarker(double InTimeMarker) override;
|
|
|
|
virtual Timing::FSelectionChangedDelegate& OnSelectionChanged() override { return OnSelectionChangedDelegate; }
|
|
virtual Timing::FTimeMarkerChangedDelegate& OnTimeMarkerChanged() override { return OnTimeMarkerChangedDelegate; }
|
|
virtual Timing::FCustomTimeMarkerChangedDelegate& OnCustomTimeMarkerChanged() override { return OnCustomTimeMarkerChangedDelegate; }
|
|
virtual Timing::FHoveredTrackChangedDelegate& OnHoveredTrackChanged() override { return OnHoveredTrackChangedDelegate; }
|
|
virtual Timing::FHoveredEventChangedDelegate& OnHoveredEventChanged() override { return OnHoveredEventChangedDelegate; }
|
|
virtual Timing::FSelectedTrackChangedDelegate& OnSelectedTrackChanged() override { return OnSelectedTrackChangedDelegate; }
|
|
virtual Timing::FSelectedEventChangedDelegate& OnSelectedEventChanged() override { return OnSelectedEventChangedDelegate; }
|
|
virtual Timing::FTrackVisibilityChangedDelegate& OnTrackVisibilityChanged() override { return OnTrackVisibilityChangedDelegate; }
|
|
virtual Timing::FTrackAddedDelegate& OnTrackAdded() override { return OnTrackAddedDelegate; }
|
|
virtual Timing::FTrackRemovedDelegate& OnTrackRemoved() override { return OnTrackRemovedDelegate; }
|
|
|
|
virtual void ResetSelectedEvent() override
|
|
{
|
|
if (SelectedEvent)
|
|
{
|
|
SelectedEvent.Reset();
|
|
OnSelectedEventChanged();
|
|
}
|
|
}
|
|
|
|
virtual void ResetEventFilter() override { SetEventFilter(nullptr); }
|
|
|
|
virtual void PreventThrottling() override;
|
|
virtual void AddOverlayWidget(const TSharedRef<SWidget>& InWidget) override;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// The callback should return 'true' to continue the enumeration.
|
|
void EnumerateAllTracks(TFunctionRef<bool(TSharedPtr<FBaseTimingTrack>&)> Callback);
|
|
|
|
const TArray<TSharedPtr<FBaseTimingTrack>>& GetTrackList(ETimingTrackLocation TrackLocation) const
|
|
{
|
|
static const TArray<TSharedPtr<FBaseTimingTrack>> EmptyTrackList;
|
|
switch (TrackLocation)
|
|
{
|
|
case ETimingTrackLocation::Scrollable: return ScrollableTracks;
|
|
case ETimingTrackLocation::TopDocked: return TopDockedTracks;
|
|
case ETimingTrackLocation::BottomDocked: return BottomDockedTracks;
|
|
case ETimingTrackLocation::Foreground: return ForegroundTracks;
|
|
default: return EmptyTrackList;
|
|
}
|
|
}
|
|
|
|
static const TCHAR* GetLocationName(ETimingTrackLocation Location);
|
|
|
|
void ChangeTrackLocation(TSharedRef<FBaseTimingTrack> Track, ETimingTrackLocation NewLocation);
|
|
bool CanChangeTrackLocation(TSharedRef<FBaseTimingTrack> Track, ETimingTrackLocation NewLocation) const;
|
|
bool CheckTrackLocation(TSharedRef<FBaseTimingTrack> Track, ETimingTrackLocation Location) const;
|
|
|
|
void UpdateScrollableTracksOrder();
|
|
int32 GetFirstScrollableTrackOrder() const;
|
|
int32 GetLastScrollableTrackOrder() const;
|
|
|
|
void HideAllScrollableTracks();
|
|
|
|
void HandleTrackVisibilityChanged();
|
|
|
|
bool IsOldGpu1TrackVisible() const;
|
|
bool IsOldGpu2TrackVisible() const;
|
|
bool IsAnyGpuTrackVisible() const;
|
|
bool IsGpuTrackVisible(uint32 InQueueId) const;
|
|
bool IsCpuTrackVisible(uint32 InThreadId) const;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const FTimingTrackViewport& GetViewport() const { return Viewport; }
|
|
|
|
const FVector2D& GetMousePosition() const { return MousePosition; }
|
|
|
|
double GetSelectionStartTime() const { return SelectionStartTime; }
|
|
double GetSelectionEndTime() const { return SelectionEndTime; }
|
|
|
|
bool IsPanning() const { return bIsPanning; }
|
|
bool IsSelecting() const { return bIsSelecting; }
|
|
|
|
bool IsTimeSelected(double Time) const { return Time >= SelectionStartTime && Time < SelectionEndTime; }
|
|
bool IsTimeSelectedInclusive(double Time) const { return Time >= SelectionStartTime && Time <= SelectionEndTime; }
|
|
|
|
bool IsAutoScrollEnabled() const { return bAutoScroll; }
|
|
void SetAutoScroll(bool bOnOff);
|
|
|
|
void ScrollAtPosY(float ScrollPosY);
|
|
void BringIntoViewY(float InTopY, float InBottomY);
|
|
void BringScrollableTrackIntoView(const FBaseTimingTrack& Track);
|
|
void ScrollAtTime(double StartTime);
|
|
void CenterOnTimeInterval(double IntervalStartTime, double IntervalDuration);
|
|
void ZoomOnTimeInterval(double IntervalStartTime, double IntervalDuration);
|
|
void BringIntoView(double StartTime, double EndTime);
|
|
void SelectTimeInterval(double IntervalStartTime, double IntervalDuration);
|
|
void SnapToFrameBound(double& IntervalStartTime, double& IntervalDuration);
|
|
void SelectToTimeMarker(double InTimeMarker);
|
|
|
|
//bool AreTimeMarkersVisible() { return MarkersTrack->IsVisible(); }
|
|
void SetTimeMarkersVisible(bool bOnOff);
|
|
//bool IsDrawOnlyBookmarksEnabled() { return MarkersTrack->IsBookmarksTrack(); }
|
|
void SetDrawOnlyBookmarks(bool bOnOff);
|
|
|
|
TSharedPtr<FTimingGraphTrack> GetMainTimingGraphTrack() { return GraphTrack; }
|
|
|
|
const TSharedPtr<FBaseTimingTrack> GetHoveredTrack() const { return HoveredTrack; }
|
|
const TSharedPtr<const ITimingEvent> GetHoveredEvent() const { return HoveredEvent; }
|
|
|
|
const TSharedPtr<FBaseTimingTrack> GetSelectedTrack() const { return SelectedTrack; }
|
|
const TSharedPtr<const ITimingEvent> GetSelectedEvent() const { return SelectedEvent; }
|
|
|
|
void SelectTimingTrack(const TSharedPtr<FBaseTimingTrack> InTrack, bool bBringTrackIntoView);
|
|
void SelectTimingEvent(const TSharedPtr<const ITimingEvent> InEvent, bool bBringEventIntoViewHorizontally, bool bBringEventIntoViewVertically = false);
|
|
void ToggleGraphSeries(const TSharedPtr<const ITimingEvent> InEvent);
|
|
|
|
const TSharedPtr<ITimingEventFilter> GetEventFilter() const { return TimingEventFilter; }
|
|
void SetEventFilter(const TSharedPtr<ITimingEventFilter> InEventFilter);
|
|
|
|
void ToggleEventFilterByEventType(const uint64 EventType);
|
|
|
|
bool IsFilterByEventType(const uint64 EventType) const;
|
|
|
|
const TSharedPtr<FBaseTimingTrack> GetTrackAt(float InPosX, float InPosY) const;
|
|
|
|
const TArray<TUniquePtr<ITimingEventRelation>>& GetCurrentRelations() const { return CurrentRelations; }
|
|
TArray<TUniquePtr<ITimingEventRelation>>& EditCurrentRelations() { return CurrentRelations; }
|
|
void AddRelation(TUniquePtr<ITimingEventRelation>& Relation) { CurrentRelations.Add(MoveTemp(Relation)); }
|
|
void ClearRelations();
|
|
|
|
TSharedPtr<FUICommandList> GetCommandList() { return CommandList; }
|
|
|
|
void CloseQuickFindTab();
|
|
|
|
TSharedPtr<UE::Insights::FFilterConfigurator> GetFilterConfigurator() { return FilterConfigurator; }
|
|
|
|
TMap<uint64, TSharedPtr<FBaseTimingTrack>>& GetAllTracks() { return AllTracks; }
|
|
|
|
void SelectEventInstance(uint32 TimerId, ESelectEventType Type, bool bUseSelection);
|
|
|
|
protected:
|
|
virtual FVector2D ComputeDesiredSize(float) const override
|
|
{
|
|
return FVector2D(16.0f, 16.0f);
|
|
}
|
|
|
|
/** Binds our UI commands to delegates. */
|
|
void BindCommands();
|
|
|
|
void CreateCompactMenuLine(FMenuBuilder& MenuBuilder, FText Label, TSharedRef<SWidget> InnerWidget) const;
|
|
TSharedRef<SWidget> MakeCompactAutoScrollOptionsMenu();
|
|
TSharedRef<SWidget> MakeAutoScrollOptionsMenu();
|
|
|
|
TSharedRef<SWidget> MakeAllTracksMenu();
|
|
void CreateAllTracksMenu(FMenuBuilder& MenuBuilder);
|
|
|
|
TSharedRef<SWidget> MakeCpuGpuTracksFilterMenu();
|
|
|
|
TSharedRef<SWidget> MakeOtherTracksFilterMenu();
|
|
bool ShowHideGraphTrack_IsChecked() const;
|
|
void ShowHideGraphTrack_Execute();
|
|
|
|
TSharedRef<SWidget> MakePluginTracksFilterMenu();
|
|
|
|
TSharedRef<SWidget> MakeViewModeMenu();
|
|
|
|
void CreateDepthLimitMenu(FMenuBuilder& MenuBuilder);
|
|
FText GetEventDepthLimitKeybindingText(uint32 DepthLimit) const;
|
|
uint32 GetNextEventDepthLimit(uint32 DepthLimit) const;
|
|
void ChooseNextEventDepthLimit();
|
|
void SetEventDepthLimit(uint32 DepthLimit);
|
|
bool CheckEventDepthLimit(uint32 DepthLimit) const;
|
|
|
|
void CreateCpuThreadTrackColoringModeMenu(FMenuBuilder& MenuBuilder);
|
|
void ChooseNextCpuThreadTrackColoringMode();
|
|
void SetCpuThreadTrackColoringMode(UE::Insights::ETimingEventsColoringMode Mode);
|
|
bool CheckCpuThreadTrackColoringMode(UE::Insights::ETimingEventsColoringMode Mode);
|
|
|
|
void ShowContextMenu(const FPointerEvent& MouseEvent);
|
|
void CreateTrackLocationMenu(FMenuBuilder& MenuBuilder, TSharedRef<FBaseTimingTrack> Track);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Auto-Scroll
|
|
|
|
void AutoScroll_OnCheckStateChanged(ECheckBoxState NewRadioState);
|
|
ECheckBoxState AutoScroll_IsChecked() const;
|
|
|
|
void SetAutoScrollFrameAlignment(int32 FrameType);
|
|
bool CompareAutoScrollFrameAlignment(int32 FrameType) const;
|
|
|
|
void SetAutoScrollViewportOffset(double Percent);
|
|
bool CompareAutoScrollViewportOffset(double Percent) const;
|
|
|
|
void SetAutoScrollDelay(double Delay);
|
|
bool CompareAutoScrollDelay(double Delay) const;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void UpdatePositionForScrollableTracks();
|
|
|
|
double EnforceHorizontalScrollLimits(const double InStartTime);
|
|
float EnforceVerticalScrollLimits(const float InScrollPosY);
|
|
|
|
/**
|
|
* Called when the user scrolls the horizontal scrollbar.
|
|
*
|
|
* @param ScrollOffset Scroll offset as a fraction between 0 and 1.
|
|
*/
|
|
void HorizontalScrollBar_OnUserScrolled(float ScrollOffset);
|
|
void UpdateHorizontalScrollBar();
|
|
|
|
/**
|
|
* Called when the user scrolls the vertical scrollbar.
|
|
*
|
|
* @param ScrollOffset Scroll offset as a fraction between 0 and 1.
|
|
*/
|
|
void VerticalScrollBar_OnUserScrolled(float ScrollOffset);
|
|
void UpdateVerticalScrollBar();
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void RaiseSelectionChanging();
|
|
void RaiseSelectionChanged();
|
|
|
|
void RaiseTimeMarkerChanging(TSharedRef<FTimeMarker> InTimeMarker);
|
|
void RaiseTimeMarkerChanged(TSharedRef<FTimeMarker> InTimeMarker);
|
|
|
|
void UpdateHoveredTimingEvent(float InMousePosX, float InMousePosY);
|
|
|
|
void OnSelectedTimingEventChanged();
|
|
|
|
void SelectHoveredTimingTrack();
|
|
void SelectHoveredTimingEvent();
|
|
|
|
void SelectLeftTimingEvent();
|
|
void SelectRightTimingEvent();
|
|
void SelectUpTimingEvent();
|
|
void SelectDownTimingEvent();
|
|
|
|
void FrameSelection();
|
|
|
|
// Get all the plugin extenders we care about
|
|
TArray<UE::Insights::Timing::ITimingViewExtender*> GetExtenders() const;
|
|
#if UE_INSIGHTS_BACKWARD_COMPATIBILITY_UE54
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
TArray<::Insights::ITimingViewExtender*> GetOldExtenders() const;
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
#endif // UE_INSIGHTS_BACKWARD_COMPATIBILITY_UE54
|
|
|
|
FReply AllowTracksToProcessOnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
|
|
FReply AllowTracksToProcessOnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
|
|
FReply AllowTracksToProcessOnMouseButtonDoubleClick(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
|
|
|
|
void SetTrackPosY(FBaseTimingTrack& Track, float TrackPosY) const;
|
|
|
|
void FindFirstEvent();
|
|
void FindPrevEvent();
|
|
void FindNextEvent();
|
|
void FindLastEvent();
|
|
void FilterAllTracks();
|
|
void ClearFilters();
|
|
|
|
TSharedRef<SDockTab> SpawnQuickFindTab(const FSpawnTabArgs& Args);
|
|
void PopulateTrackSuggestionList(const FString& Text, TArray<FString>& OutSuggestions);
|
|
void PopulateTimerNameSuggestionList(const FString& Text, TArray<FString>& OutSuggestions);
|
|
|
|
typedef TFunctionRef<void(TSharedPtr<const FBaseTimingTrack> Track)> EnumerateFilteredTracksCallback;
|
|
void EnumerateFilteredTracks(TSharedPtr<UE::Insights::FFilterConfigurator> FilterConfigurator, TSharedPtr<const FBaseTimingTrack> PriorityTrack, EnumerateFilteredTracksCallback Callback);
|
|
|
|
ETraceFrameType GetFrameTypeToSnapTo();
|
|
|
|
/** The FilterConfigurator needs to be updated so that custom filters work correctly when analysis is still running
|
|
* and the timer list can change.
|
|
*/
|
|
void UpdateFilters();
|
|
|
|
bool IsInTimingProfiler() const;
|
|
TSharedPtr<STimersView> GetTimersView() const;
|
|
TSharedPtr<SLogView> GetLogView() const;
|
|
|
|
protected:
|
|
/** The name of the view. */
|
|
FName ViewName;
|
|
|
|
/** The track's viewport. Encapsulates info about position and scale. */
|
|
FTimingTrackViewport Viewport;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
/** All created tracks.
|
|
* Maps track id to track pointer.
|
|
*/
|
|
TMap<uint64, TSharedPtr<FBaseTimingTrack>> AllTracks;
|
|
|
|
TArray<TSharedPtr<FBaseTimingTrack>> TopDockedTracks; /**< tracks docked on top, in the order to be displayed (top to bottom) */
|
|
TArray<TSharedPtr<FBaseTimingTrack>> BottomDockedTracks; /**< tracks docked on bottom, in the order to be displayed (top to bottom) */
|
|
TArray<TSharedPtr<FBaseTimingTrack>> ScrollableTracks; /**< tracks in scrollable area, in the order to be displayed (top to bottom) */
|
|
TArray<TSharedPtr<FBaseTimingTrack>> ForegroundTracks; /**< tracks to draw over top/scrollable/bottom tracks (can use entire area), in the order to be displayed (back to front) */
|
|
|
|
/** Whether the order of scrollable tracks is dirty and list need to be re-sorted */
|
|
bool bScrollableTracksOrderIsDirty;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
// Shared state for Frame Thread tracks
|
|
TSharedPtr<FFrameSharedState> FrameSharedState;
|
|
|
|
// Shared state for CPU/GPU Thread tracks
|
|
TSharedPtr<FThreadTimingSharedState> ThreadTimingSharedState;
|
|
|
|
// Shared state for Asset Loading tracks
|
|
TSharedPtr<LoadingProfiler::FLoadingSharedState> LoadingSharedState;
|
|
|
|
// Shared state for File Activity (I/O) tracks
|
|
TSharedPtr<FFileActivitySharedState> FileActivitySharedState;
|
|
|
|
// Shared state for Regions tracks
|
|
TSharedPtr<FTimingRegionsSharedState> TimingRegionsSharedState;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
/** The time ruler track. It includes the custom time markers (ones user can drag with mouse). */
|
|
TSharedRef<FTimeRulerTrack> TimeRulerTrack;
|
|
|
|
/** The default time marker (for backward compatibility). */
|
|
TSharedRef<FTimeMarker> DefaultTimeMarker;
|
|
|
|
/** The time markers track. It displays fixed time markers based on bookmarks and log messages. */
|
|
TSharedRef<FMarkersTimingTrack> MarkersTrack;
|
|
|
|
/** A graph track for frame times and CPU/GPU timing graphs. */
|
|
TSharedPtr<FTimingGraphTrack> GraphTrack;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
/** The extension overlay containing external sub-widgets */
|
|
TSharedPtr<SOverlay> ExtensionOverlay;
|
|
|
|
/** Horizontal scroll bar, used for scrolling timing events' viewport. */
|
|
TSharedPtr<SScrollBar> HorizontalScrollBar;
|
|
|
|
/** Vertical scroll bar, used for scrolling timing events' viewport. */
|
|
TSharedPtr<SScrollBar> VerticalScrollBar;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
/** The current mouse position. */
|
|
FVector2D MousePosition;
|
|
|
|
/** Mouse position during the call on mouse button down. */
|
|
FVector2D MousePositionOnButtonDown;
|
|
double ViewportStartTimeOnButtonDown;
|
|
float ViewportScrollPosYOnButtonDown;
|
|
|
|
/** Mouse position during the call on mouse button up. */
|
|
FVector2D MousePositionOnButtonUp;
|
|
|
|
float LastScrollPosY;
|
|
|
|
bool bIsLMB_Pressed;
|
|
bool bIsRMB_Pressed;
|
|
|
|
bool bIsSpaceBarKeyPressed;
|
|
bool bIsDragging;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Auto-Scroll
|
|
|
|
/** True if the viewport scrolls automatically. */
|
|
bool bAutoScroll;
|
|
|
|
/**
|
|
* Frame Alignment. Controls if auto-scroll should align center of the viewport with start of a frame or not.
|
|
* Valid options: -1 to disable frame alignment or the type of frame to align with (0 = Game or 1 = Rendering; see ETraceFrameType).
|
|
*/
|
|
int32 AutoScrollFrameAlignment;
|
|
|
|
/**
|
|
* Viewport offset while auto-scrolling, as percent of viewport width.
|
|
* If positive, it offsets the viewport forward, allowing an empty space at the right side of the viewport (i.e. after end of session).
|
|
* If negative, it offsets the viewport backward (i.e. end of session will be outside viewport).
|
|
*/
|
|
double AutoScrollViewportOffsetPercent;
|
|
|
|
/** Minimum time between two auto-scroll updates, in [seconds]. */
|
|
double AutoScrollMinDelay;
|
|
|
|
/** Timestamp of last auto-scroll update, in [cycle64]. */
|
|
uint64 LastAutoScrollTime;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Panning
|
|
|
|
/** True, if the user is currently interactively panning the view (horizontally and/or vertically). */
|
|
bool bIsPanning;
|
|
|
|
/** If enabled, the panning is allowed to continue when mouse cursor reaches the edges of the screen. */
|
|
bool bAllowPanningOnScreenEdges;
|
|
|
|
float DPIScaleFactor;
|
|
|
|
uint32 EdgeFrameCountX;
|
|
uint32 EdgeFrameCountY;
|
|
|
|
/** How to pan. */
|
|
enum class EPanningMode : uint8
|
|
{
|
|
None = 0,
|
|
Horizontal = 0x01,
|
|
Vertical = 0x02,
|
|
HorizontalAndVertical = Horizontal | Vertical,
|
|
};
|
|
EPanningMode PanningMode;
|
|
|
|
float OverscrollLeft;
|
|
float OverscrollRight;
|
|
float OverscrollTop;
|
|
float OverscrollBottom;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Selection
|
|
|
|
/** True, if the user is currently changing the selection. */
|
|
bool bIsSelecting;
|
|
|
|
double SelectionStartTime;
|
|
double SelectionEndTime;
|
|
|
|
TSharedPtr<FBaseTimingTrack> HoveredTrack;
|
|
TSharedPtr<const ITimingEvent> HoveredEvent;
|
|
|
|
TSharedPtr<FBaseTimingTrack> SelectedTrack;
|
|
TSharedPtr<const ITimingEvent> SelectedEvent;
|
|
|
|
TSharedPtr<ITimingEventFilter> TimingEventFilter;
|
|
|
|
FTooltipDrawState Tooltip;
|
|
|
|
enum class ESelectionType
|
|
{
|
|
None,
|
|
TimeRange,
|
|
TimingEvent
|
|
};
|
|
ESelectionType LastSelectionType;
|
|
|
|
/** Throttle flag, allowing tracks to control whether Slate throttle should take place */
|
|
bool bPreventThrottling;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Misc
|
|
|
|
FGeometry ThisGeometry;
|
|
|
|
const FSlateBrush* WhiteBrush;
|
|
const FSlateFontInfo MainFont;
|
|
|
|
bool bDrawTopSeparatorLine;
|
|
bool bDrawBottomSeparatorLine;
|
|
|
|
bool bBringSelectedEventIntoViewVerticallyOnNextTick = false;
|
|
|
|
// Debug stats
|
|
int32 NumUpdatedEvents;
|
|
TFixedCircularBuffer<uint64, 32> PreUpdateTracksDurationHistory;
|
|
TFixedCircularBuffer<uint64, 32> UpdateTracksDurationHistory;
|
|
TFixedCircularBuffer<uint64, 32> PostUpdateTracksDurationHistory;
|
|
TFixedCircularBuffer<uint64, 32> TickDurationHistory;
|
|
mutable TFixedCircularBuffer<uint64, 32> PreDrawTracksDurationHistory;
|
|
mutable TFixedCircularBuffer<uint64, 32> DrawTracksDurationHistory;
|
|
mutable TFixedCircularBuffer<uint64, 32> PostDrawTracksDurationHistory;
|
|
mutable TFixedCircularBuffer<uint64, 32> TotalDrawDurationHistory;
|
|
mutable TFixedCircularBuffer<uint64, 32> OnPaintDeltaTimeHistory;
|
|
mutable uint64 LastOnPaintTime;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Delegates
|
|
|
|
Timing::FSelectionChangedDelegate OnSelectionChangedDelegate;
|
|
Timing::FTimeMarkerChangedDelegate OnTimeMarkerChangedDelegate;
|
|
Timing::FCustomTimeMarkerChangedDelegate OnCustomTimeMarkerChangedDelegate;
|
|
Timing::FHoveredTrackChangedDelegate OnHoveredTrackChangedDelegate;
|
|
Timing::FHoveredEventChangedDelegate OnHoveredEventChangedDelegate;
|
|
Timing::FSelectedTrackChangedDelegate OnSelectedTrackChangedDelegate;
|
|
Timing::FSelectedEventChangedDelegate OnSelectedEventChangedDelegate;
|
|
Timing::FTrackVisibilityChangedDelegate OnTrackVisibilityChangedDelegate;
|
|
Timing::FTrackAddedDelegate OnTrackAddedDelegate;
|
|
Timing::FTrackRemovedDelegate OnTrackRemovedDelegate;
|
|
|
|
TSharedPtr<FUICommandList> CommandList;
|
|
|
|
TArray<TUniquePtr<ITimingEventRelation>> CurrentRelations;
|
|
|
|
TSharedPtr<::Insights::FQuickFind> QuickFindVm;
|
|
TSharedPtr<FFilterConfigurator> FilterConfigurator;
|
|
static uint32 TimingViewId;
|
|
const FName QuickFindTabId;
|
|
bool bUpdateFilters = true;
|
|
|
|
// Used only between the creation of the widget and the spawning of the owning tab. When the tab is spawned, we relinquish ownership.
|
|
TSharedPtr<::Insights::SQuickFind> QuickFindWidgetSharedPtr;
|
|
TWeakPtr<::Insights::SQuickFind> QuickFindWidgetWeakPtr;
|
|
};
|
|
|
|
} // namespace UE::Insights::TimingProfiler
|