diff --git a/Gems/LyShine/Code/Editor/Animation/AnimationContext.h b/Gems/LyShine/Code/Editor/Animation/AnimationContext.h
index 9534902f99..cb45fb9653 100644
--- a/Gems/LyShine/Code/Editor/Animation/AnimationContext.h
+++ b/Gems/LyShine/Code/Editor/Animation/AnimationContext.h
@@ -167,12 +167,12 @@ public:
     void UpdateTimeRange();
 
 private:
-    virtual void BeginUndoTransaction() override;
-    virtual void EndUndoTransaction() override;
+    void BeginUndoTransaction() override;
+    void EndUndoTransaction() override;
 
-    virtual void OnSequenceRemoved(CUiAnimViewSequence* pSequence) override;
+    void OnSequenceRemoved(CUiAnimViewSequence* pSequence) override;
 
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     void AnimateActiveSequence();
 
diff --git a/Gems/LyShine/Code/Editor/Animation/Controls/UiSplineCtrlEx.h b/Gems/LyShine/Code/Editor/Animation/Controls/UiSplineCtrlEx.h
index 1bbcf8eea7..05b86bd380 100644
--- a/Gems/LyShine/Code/Editor/Animation/Controls/UiSplineCtrlEx.h
+++ b/Gems/LyShine/Code/Editor/Animation/Controls/UiSplineCtrlEx.h
@@ -345,8 +345,8 @@ public:
     SplineWidget(QWidget* parent);
     virtual ~SplineWidget();
 
-    void update() { QWidget::update(); }
-    void update(const QRect& rect) { QWidget::update(rect); }
+    void update() override { QWidget::update(); }
+    void update(const QRect& rect) override { QWidget::update(rect); }
 
     QPoint mapFromGlobal(const QPoint& point) const override { return QWidget::mapFromGlobal(point); }
 
diff --git a/Gems/LyShine/Code/Editor/Animation/Controls/UiTimelineCtrl.h b/Gems/LyShine/Code/Editor/Animation/Controls/UiTimelineCtrl.h
index 701d187ddc..ed0d8ce02d 100644
--- a/Gems/LyShine/Code/Editor/Animation/Controls/UiTimelineCtrl.h
+++ b/Gems/LyShine/Code/Editor/Animation/Controls/UiTimelineCtrl.h
@@ -54,7 +54,7 @@ public:
     void setGeometry(const QRect& r) override { QWidget::setGeometry(r); }
 
     void SetTimeRange(const Range& r) { m_timeRange = r; }
-    void SetTimeMarker(float fTime);
+    void SetTimeMarker(float fTime) override;
     float GetTimeMarker() const { return m_fTimeMarker; }
 
     void SetZoom(float fZoom);
@@ -111,7 +111,7 @@ protected:
     void OnLButtonUp(const QPoint& point, Qt::KeyboardModifiers modifiers);
     void OnRButtonDown(const QPoint& point, Qt::KeyboardModifiers modifiers);
     void OnRButtonUp(const QPoint& point, Qt::KeyboardModifiers modifiers);
-    void keyPressEvent(QKeyEvent* event);
+    void keyPressEvent(QKeyEvent* event) override;
 
     // Drawing functions
     float  ClientToTime(int x);
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAVTrackEventKeyUIControls.h b/Gems/LyShine/Code/Editor/Animation/UiAVTrackEventKeyUIControls.h
index df3b7fa24f..ed47e6a160 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAVTrackEventKeyUIControls.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAVTrackEventKeyUIControls.h
@@ -17,13 +17,13 @@ public:
     CSmartVariableEnum<QString> mv_event;
     CSmartVariable<QString> mv_value;
 
-    virtual void OnCreateVars();
+    void OnCreateVars() override;
     bool SupportTrackType(const CUiAnimParamType& paramType, EUiAnimCurveType trackType, EUiAnimValue valueType) const override;
 
     bool OnKeySelectionChange(CUiAnimViewKeyBundle& selectedKeys) override;
     void OnUIChange(IVariable* pVar, CUiAnimViewKeyBundle& keys) override;
 
-    virtual unsigned int GetPriority() const { return 1; }
+    unsigned int GetPriority() const override { return 1; }
 
     static const GUID& GetClassID()
     {
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewCurveEditor.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewCurveEditor.h
index edde246e1c..863e8c1cdd 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewCurveEditor.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewCurveEditor.h
@@ -49,8 +49,8 @@ public:
     void SetPlayCallback(const std::function<void()>& callback);
 
     // IUiAnimationContextListener
-    virtual void OnSequenceChanged(CUiAnimViewSequence* pNewSequence);
-    virtual void OnTimeChanged(float newTime);
+    void OnSequenceChanged(CUiAnimViewSequence* pNewSequence) override;
+    void OnTimeChanged(float newTime) override;
 
 protected:
     void showEvent(QShowEvent* event) override;
@@ -112,8 +112,8 @@ public:
     float GetFPS() const { return m_widget->GetFPS(); }
     void SetTickDisplayMode(EUiAVTickMode mode) { m_widget->SetTickDisplayMode(mode); }
 
-    virtual void OnSequenceChanged(CUiAnimViewSequence* pNewSequence) { m_widget->OnSequenceChanged(pNewSequence); }
-    virtual void OnTimeChanged(float newTime) { m_widget->OnTimeChanged(newTime); }
+    void OnSequenceChanged(CUiAnimViewSequence* pNewSequence) override { m_widget->OnSequenceChanged(pNewSequence); }
+    void OnTimeChanged(float newTime) override { m_widget->OnTimeChanged(newTime); }
 
     virtual void OnKeysChanged(CUiAnimViewSequence* pSequence) override { m_widget->OnKeysChanged(pSequence); }
     virtual void OnKeySelectionChanged(CUiAnimViewSequence* pSequence) override { m_widget->OnKeySelectionChanged(pSequence); }
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewDialog.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewDialog.h
index a7ecbd3499..4671612695 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewDialog.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewDialog.h
@@ -70,7 +70,7 @@ public:
 
     // UiEditorAnimationStateInterface
     UiEditorAnimationStateInterface::UiEditorAnimationEditState GetCurrentEditState() override;
-    void RestoreCurrentEditState(const UiEditorAnimationStateInterface::UiEditorAnimationEditState& animEditState);
+    void RestoreCurrentEditState(const UiEditorAnimationStateInterface::UiEditorAnimationEditState& animEditState) override;
     // ~UiEditorAnimationStateInterface
 
     // UiEditorAnimListenerInterface
@@ -167,11 +167,11 @@ private:
     virtual void OnNodeSelectionChanged(CUiAnimViewSequence* pSequence) override;
     virtual void OnNodeRenamed(CUiAnimViewNode* pNode, const char* pOldName) override;
 
-    virtual void OnSequenceAdded(CUiAnimViewSequence* pSequence);
-    virtual void OnSequenceRemoved(CUiAnimViewSequence* pSequence);
+    void OnSequenceAdded(CUiAnimViewSequence* pSequence) override;
+    void OnSequenceRemoved(CUiAnimViewSequence* pSequence) override;
 
-    virtual void BeginUndoTransaction();
-    virtual void EndUndoTransaction();
+    void BeginUndoTransaction() override;
+    void EndUndoTransaction() override;
     void SaveSequenceTimingToXML();
 
     // Instance
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewDopeSheetBase.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewDopeSheetBase.h
index ff1984184f..504c39e630 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewDopeSheetBase.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewDopeSheetBase.h
@@ -87,7 +87,7 @@ public:
     void SetEditLock(bool bLock) { m_bEditLock = bLock; }
 
     // IUiAnimationContextListener
-    virtual void OnTimeChanged(float newTime);
+    void OnTimeChanged(float newTime) override;
 
     float TickSnap(float time) const;
 
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequence.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequence.h
index 3aa8d74563..494cebd573 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequence.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequence.h
@@ -234,17 +234,17 @@ private:
     // Called when an animation updates needs to be schedules
     void ForceAnimation();
 
-    virtual void CopyKeysToClipboard(XmlNodeRef& xmlNode, const bool bOnlySelectedKeys, const bool bOnlyFromSelectedTracks) override;
+    void CopyKeysToClipboard(XmlNodeRef& xmlNode, const bool bOnlySelectedKeys, const bool bOnlyFromSelectedTracks) override;
 
     void UpdateLightAnimationRefs(const char* pOldName, const char* pNewName);
 
     std::deque<CUiAnimViewTrack*> GetMatchingTracks(CUiAnimViewAnimNode* pAnimNode, XmlNodeRef trackNode);
     void GetMatchedPasteLocationsRec(std::vector<TMatchedTrackLocation>& locations, CUiAnimViewNode* pCurrentNode, XmlNodeRef clipboardNode);
 
-    virtual void BeginUndoTransaction();
-    virtual void EndUndoTransaction();
-    virtual void BeginRestoreTransaction();
-    virtual void EndRestoreTransaction();
+    void BeginUndoTransaction() override;
+    void EndUndoTransaction() override;
+    void BeginRestoreTransaction() override;
+    void EndRestoreTransaction() override;
 
     // Current time when animated
     float m_time;
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequenceManager.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequenceManager.h
index f29f0e58e1..1fe9d96f85 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequenceManager.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSequenceManager.h
@@ -35,7 +35,7 @@ public:
     CUiAnimViewSequenceManager();
     ~CUiAnimViewSequenceManager();
 
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     unsigned int GetCount() const { return static_cast<unsigned int>(m_sequences.size()); }
 
diff --git a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSplineCtrl.h b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSplineCtrl.h
index 8dd0ec0c79..45b3816f29 100644
--- a/Gems/LyShine/Code/Editor/Animation/UiAnimViewSplineCtrl.h
+++ b/Gems/LyShine/Code/Editor/Animation/UiAnimViewSplineCtrl.h
@@ -26,7 +26,7 @@ public:
     CUiAnimViewSplineCtrl(QWidget* parent);
     virtual ~CUiAnimViewSplineCtrl();
 
-    virtual void ClearSelection();
+    void ClearSelection() override;
 
     void AddSpline(ISplineInterpolator* pSpline, CUiAnimViewTrack* pTrack, const QColor& color);
     void AddSpline(ISplineInterpolator * pSpline, CUiAnimViewTrack * pTrack, QColor anColorArray[4]);
@@ -64,7 +64,7 @@ private:
     void AdjustTCB(float d_tension, float d_continuity, float d_bias);
     void MoveSelectedTangentHandleTo(const QPoint& point);
 
-    virtual ISplineCtrlUndo* CreateSplineCtrlUndoObject(std::vector<ISplineInterpolator*>& splineContainer);
+    ISplineCtrlUndo* CreateSplineCtrlUndoObject(std::vector<ISplineInterpolator*>& splineContainer) override;
 
     bool m_bKeysFreeze;
     bool m_bTangentsFreeze;
diff --git a/Gems/LyShine/Code/Source/Animation/AnimNode.h b/Gems/LyShine/Code/Source/Animation/AnimNode.h
index 6ac198a5c7..0076276204 100644
--- a/Gems/LyShine/Code/Source/Animation/AnimNode.h
+++ b/Gems/LyShine/Code/Source/Animation/AnimNode.h
@@ -64,10 +64,10 @@ public:
     // Return Animation Sequence that owns this node.
     IUiAnimSequence* GetSequence() const override { return m_pSequence; };
 
-    void SetFlags(int flags);
-    int GetFlags() const;
+    void SetFlags(int flags) override;
+    int GetFlags() const override;
 
-    IUiAnimationSystem* GetUiAnimationSystem() const { return m_pSequence->GetUiAnimationSystem(); };
+    IUiAnimationSystem* GetUiAnimationSystem() const override { return m_pSequence->GetUiAnimationSystem(); };
 
     virtual void OnStart() {}
     void OnReset() override {}
@@ -80,23 +80,23 @@ public:
     virtual Matrix34 GetReferenceMatrix() const;
 
     //////////////////////////////////////////////////////////////////////////
-    bool IsParamValid(const CUiAnimParamType& paramType) const;
+    bool IsParamValid(const CUiAnimParamType& paramType) const override;
     AZStd::string GetParamName(const CUiAnimParamType& param) const override;
-    virtual EUiAnimValue GetParamValueType(const CUiAnimParamType& paramType) const;
-    virtual IUiAnimNode::ESupportedParamFlags GetParamFlags(const CUiAnimParamType& paramType) const;
-    virtual unsigned int GetParamCount() const { return 0; };
+    EUiAnimValue GetParamValueType(const CUiAnimParamType& paramType) const override;
+    IUiAnimNode::ESupportedParamFlags GetParamFlags(const CUiAnimParamType& paramType) const override;
+    unsigned int GetParamCount() const override { return 0; };
 
-    bool SetParamValue(float time, CUiAnimParamType param, float val);
-    bool SetParamValue(float time, CUiAnimParamType param, const Vec3& val);
-    bool SetParamValue(float time, CUiAnimParamType param, const Vec4& val);
-    bool GetParamValue(float time, CUiAnimParamType param, float& val);
-    bool GetParamValue(float time, CUiAnimParamType param, Vec3& val);
-    bool GetParamValue(float time, CUiAnimParamType param, Vec4& val);
+    bool SetParamValue(float time, CUiAnimParamType param, float val) override;
+    bool SetParamValue(float time, CUiAnimParamType param, const Vec3& val) override;
+    bool SetParamValue(float time, CUiAnimParamType param, const Vec4& val) override;
+    bool GetParamValue(float time, CUiAnimParamType param, float& val) override;
+    bool GetParamValue(float time, CUiAnimParamType param, Vec3& val) override;
+    bool GetParamValue(float time, CUiAnimParamType param, Vec4& val) override;
 
     void SetTarget([[maybe_unused]] IUiAnimNode* node) {};
     IUiAnimNode* GetTarget() const { return 0; };
 
-    void StillUpdate() {}
+    void StillUpdate() override {}
     void Animate(SUiAnimContext& ec) override;
 
     virtual void PrecacheStatic([[maybe_unused]] float startTime) {}
@@ -109,7 +109,7 @@ public:
     IUiAnimNodeOwner* GetNodeOwner() override { return m_pOwner; };
 
     // Called by sequence when needs to activate a node.
-    virtual void Activate(bool bActivate);
+    void Activate(bool bActivate) override;
 
     //////////////////////////////////////////////////////////////////////////
     void SetParent(IUiAnimNode* pParent) override;
@@ -132,7 +132,7 @@ public:
     IUiAnimTrack* GetTrackForAzField([[maybe_unused]] const UiAnimParamData& param) const override { return nullptr; }
     IUiAnimTrack* CreateTrackForAzField([[maybe_unused]] const UiAnimParamData& param) override { return nullptr; }
 
-    virtual void SetTrack(const CUiAnimParamType& paramType, IUiAnimTrack* track);
+    void SetTrack(const CUiAnimParamType& paramType, IUiAnimTrack* track) override;
     IUiAnimTrack* CreateTrack(const CUiAnimParamType& paramType) override;
     void SetTimeRange(Range timeRange) override;
     void AddTrack(IUiAnimTrack* track) override;
@@ -147,7 +147,7 @@ public:
     void SetId(int id) { m_id = id; }
     const char* GetNameFast() const { return m_name.c_str(); }
 
-    virtual void Render(){}
+    void Render() override{}
 
     static void Reflect(AZ::SerializeContext* serializeContext);
 
@@ -168,7 +168,7 @@ protected:
     // sets track animNode pointer to this node and sorts tracks
     void RegisterTrack(IUiAnimTrack* track);
 
-    virtual bool NeedToRender() const { return false; }
+    bool NeedToRender() const override { return false; }
 
 protected:
     int m_refCount;
@@ -199,7 +199,7 @@ class CUiAnimNodeGroup
 public:
     CUiAnimNodeGroup(const int id)
         : CUiAnimNode(id, eUiAnimNodeType_Group) { SetFlags(GetFlags() | eUiAnimNodeFlags_CanChangeName); }
-    EUiAnimNodeType GetType() const { return eUiAnimNodeType_Group; }
+    EUiAnimNodeType GetType() const override { return eUiAnimNodeType_Group; }
 
-    virtual CUiAnimParamType GetParamType([[maybe_unused]] unsigned int nIndex) const { return eUiAnimParamType_Invalid; }
+    CUiAnimParamType GetParamType([[maybe_unused]] unsigned int nIndex) const override { return eUiAnimParamType_Invalid; }
 };
diff --git a/Gems/LyShine/Code/Source/Animation/AnimSequence.h b/Gems/LyShine/Code/Source/Animation/AnimSequence.h
index e4026ce250..1451770b4e 100644
--- a/Gems/LyShine/Code/Source/Animation/AnimSequence.h
+++ b/Gems/LyShine/Code/Source/Animation/AnimSequence.h
@@ -34,95 +34,95 @@ public:
     // Animation system.
     IUiAnimationSystem* GetUiAnimationSystem() const override { return m_pUiAnimationSystem; };
 
-    void SetName(const char* name);
-    const char* GetName() const;
-    uint32 GetId() const { return m_id; }
+    void SetName(const char* name) override;
+    const char* GetName() const override;
+    uint32 GetId() const override { return m_id; }
 
     float GetTime() const { return m_time; }
 
-    virtual void SetOwner(IUiAnimSequenceOwner* pOwner) { m_pOwner = pOwner; }
-    virtual IUiAnimSequenceOwner* GetOwner() const { return m_pOwner; }
+    void SetOwner(IUiAnimSequenceOwner* pOwner) override { m_pOwner = pOwner; }
+    IUiAnimSequenceOwner* GetOwner() const override { return m_pOwner; }
 
-    virtual void SetActiveDirector(IUiAnimNode* pDirectorNode);
-    virtual IUiAnimNode* GetActiveDirector() const;
+    void SetActiveDirector(IUiAnimNode* pDirectorNode) override;
+    IUiAnimNode* GetActiveDirector() const override;
 
-    virtual void SetFlags(int flags);
-    virtual int GetFlags() const;
-    virtual int GetCutSceneFlags(const bool localFlags = false) const;
+    void SetFlags(int flags) override;
+    int GetFlags() const override;
+    int GetCutSceneFlags(const bool localFlags = false) const override;
 
-    virtual void SetParentSequence(IUiAnimSequence* pParentSequence);
-    virtual const IUiAnimSequence* GetParentSequence() const;
-    virtual bool IsAncestorOf(const IUiAnimSequence* pSequence) const;
+    void SetParentSequence(IUiAnimSequence* pParentSequence) override;
+    const IUiAnimSequence* GetParentSequence() const override;
+    bool IsAncestorOf(const IUiAnimSequence* pSequence) const override;
 
-    void SetTimeRange(Range timeRange);
-    Range GetTimeRange() { return m_timeRange; };
+    void SetTimeRange(Range timeRange) override;
+    Range GetTimeRange() override { return m_timeRange; };
 
-    void AdjustKeysToTimeRange(const Range& timeRange);
+    void AdjustKeysToTimeRange(const Range& timeRange) override;
 
     //! Return number of animation nodes in sequence.
-    int GetNodeCount() const;
+    int GetNodeCount() const override;
     //! Get specified animation node.
-    IUiAnimNode* GetNode(int index) const;
+    IUiAnimNode* GetNode(int index) const override;
 
-    IUiAnimNode* FindNodeByName(const char* sNodeName, const IUiAnimNode* pParentDirector);
+    IUiAnimNode* FindNodeByName(const char* sNodeName, const IUiAnimNode* pParentDirector) override;
     IUiAnimNode* FindNodeById(int nNodeId);
-    virtual void ReorderNode(IUiAnimNode* node, IUiAnimNode* pPivotNode, bool next);
+    void ReorderNode(IUiAnimNode* node, IUiAnimNode* pPivotNode, bool next) override;
 
-    void Reset(bool bSeekToStart);
-    void ResetHard();
-    void Pause();
-    void Resume();
-    bool IsPaused() const;
+    void Reset(bool bSeekToStart) override;
+    void ResetHard() override;
+    void Pause() override;
+    void Resume() override;
+    bool IsPaused() const override;
 
     virtual void OnStart();
     virtual void OnStop();
     void OnLoop() override;
 
     //! Add animation node to sequence.
-    bool AddNode(IUiAnimNode* node);
-    IUiAnimNode* CreateNode(EUiAnimNodeType nodeType);
-    IUiAnimNode* CreateNode(XmlNodeRef node);
-    void RemoveNode(IUiAnimNode* node);
+    bool AddNode(IUiAnimNode* node) override;
+    IUiAnimNode* CreateNode(EUiAnimNodeType nodeType) override;
+    IUiAnimNode* CreateNode(XmlNodeRef node) override;
+    void RemoveNode(IUiAnimNode* node) override;
     //! Add scene node to sequence.
-    void RemoveAll();
+    void RemoveAll() override;
 
-    virtual void Activate();
-    virtual bool IsActivated() const { return m_bActive; }
-    virtual void Deactivate();
+    void Activate() override;
+    bool IsActivated() const override { return m_bActive; }
+    void Deactivate() override;
 
-    virtual void PrecacheData(float startTime);
+    void PrecacheData(float startTime) override;
     void PrecacheStatic(const float startTime);
     void PrecacheDynamic(float time);
 
-    void StillUpdate();
-    void Animate(const SUiAnimContext& ec);
-    void Render();
+    void StillUpdate() override;
+    void Animate(const SUiAnimContext& ec) override;
+    void Render() override;
 
-    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true, uint32 overrideId = 0, bool bResetLightAnimSet = false);
-    void InitPostLoad(IUiAnimationSystem* pUiAnimationSystem, bool remapIds, LyShine::EntityIdMap* entityIdMap);
+    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true, uint32 overrideId = 0, bool bResetLightAnimSet = false) override;
+    void InitPostLoad(IUiAnimationSystem* pUiAnimationSystem, bool remapIds, LyShine::EntityIdMap* entityIdMap) override;
 
-    void CopyNodes(XmlNodeRef& xmlNode, IUiAnimNode** pSelectedNodes, uint32 count);
-    void PasteNodes(const XmlNodeRef& xmlNode, IUiAnimNode* pParent);
+    void CopyNodes(XmlNodeRef& xmlNode, IUiAnimNode** pSelectedNodes, uint32 count) override;
+    void PasteNodes(const XmlNodeRef& xmlNode, IUiAnimNode* pParent) override;
 
     //! Add/remove track events in sequence
-    virtual bool AddTrackEvent(const char* szEvent);
-    virtual bool RemoveTrackEvent(const char* szEvent);
-    virtual bool RenameTrackEvent(const char* szEvent, const char* szNewEvent);
-    virtual bool MoveUpTrackEvent(const char* szEvent);
-    virtual bool MoveDownTrackEvent(const char* szEvent);
-    virtual void ClearTrackEvents();
+    bool AddTrackEvent(const char* szEvent) override;
+    bool RemoveTrackEvent(const char* szEvent) override;
+    bool RenameTrackEvent(const char* szEvent, const char* szNewEvent) override;
+    bool MoveUpTrackEvent(const char* szEvent) override;
+    bool MoveDownTrackEvent(const char* szEvent) override;
+    void ClearTrackEvents() override;
 
     //! Get the track events in the sequence
-    virtual int GetTrackEventsCount() const;
-    virtual char const* GetTrackEvent(int iIndex) const;
-    virtual IUiAnimStringTable* GetTrackEventStringTable() { return m_pEventStrings.get(); }
+    int GetTrackEventsCount() const override;
+    char const* GetTrackEvent(int iIndex) const override;
+    IUiAnimStringTable* GetTrackEventStringTable() override { return m_pEventStrings.get(); }
 
     //! Call to trigger a track event
-    virtual void TriggerTrackEvent(const char* event, const char* param = NULL);
+    void TriggerTrackEvent(const char* event, const char* param = NULL) override;
 
     //! Track event listener
-    virtual void AddTrackEventListener(IUiTrackEventListener* pListener);
-    virtual void RemoveTrackEventListener(IUiTrackEventListener* pListener);
+    void AddTrackEventListener(IUiTrackEventListener* pListener) override;
+    void RemoveTrackEventListener(IUiTrackEventListener* pListener) override;
 
     static void Reflect(AZ::SerializeContext* serializeContext);
 
diff --git a/Gems/LyShine/Code/Source/Animation/AnimSplineTrack.h b/Gems/LyShine/Code/Source/Animation/AnimSplineTrack.h
index 0bc625155a..bf49546916 100644
--- a/Gems/LyShine/Code/Source/Animation/AnimSplineTrack.h
+++ b/Gems/LyShine/Code/Source/Animation/AnimSplineTrack.h
@@ -45,23 +45,23 @@ public:
     void release() override;
     //////////////////////////////////////////////////////////////////////////
 
-    virtual int GetSubTrackCount() const { return 0; };
-    virtual IUiAnimTrack* GetSubTrack([[maybe_unused]] int nIndex) const { return 0; };
+    int GetSubTrackCount() const override { return 0; };
+    IUiAnimTrack* GetSubTrack([[maybe_unused]] int nIndex) const override { return 0; };
     AZStd::string GetSubTrackName([[maybe_unused]] int nIndex) const override { return AZStd::string(); };
-    virtual void SetSubTrackName([[maybe_unused]] int nIndex, [[maybe_unused]] const char* name) { assert(0); }
+    void SetSubTrackName([[maybe_unused]] int nIndex, [[maybe_unused]] const char* name) override { assert(0); }
 
-    virtual const CUiAnimParamType& GetParameterType() const { return m_nParamType; };
-    virtual void SetParameterType(CUiAnimParamType type) { m_nParamType = type; };
+    const CUiAnimParamType& GetParameterType() const override { return m_nParamType; };
+    void SetParameterType(CUiAnimParamType type) override { m_nParamType = type; };
 
-    virtual const UiAnimParamData& GetParamData() const { return m_componentParamData; }
-    virtual void SetParamData(const UiAnimParamData& param) { m_componentParamData = param; }
+    const UiAnimParamData& GetParamData() const override { return m_componentParamData; }
+    void SetParamData(const UiAnimParamData& param) override { m_componentParamData = param; }
 
-    virtual void GetKeyValueRange(float& fMin, float& fMax) const { fMin = m_fMinKeyValue; fMax = m_fMaxKeyValue; };
-    virtual void SetKeyValueRange(float fMin, float fMax){ m_fMinKeyValue = fMin; m_fMaxKeyValue = fMax; };
+    void GetKeyValueRange(float& fMin, float& fMax) const override { fMin = m_fMinKeyValue; fMax = m_fMaxKeyValue; };
+    void SetKeyValueRange(float fMin, float fMax) override{ m_fMinKeyValue = fMin; m_fMaxKeyValue = fMax; };
 
-    ISplineInterpolator* GetSpline() const { return m_spline.get(); };
+    ISplineInterpolator* GetSpline() const override { return m_spline.get(); };
 
-    virtual bool IsKeySelected(int key) const
+    bool IsKeySelected(int key) const override
     {
         if (GetSpline() && GetSpline()->IsKeySelectedAtAnyDimension(key))
         {
@@ -70,7 +70,7 @@ public:
         return false;
     }
 
-    virtual void SelectKey(int key, bool select)
+    void SelectKey(int key, bool select) override
     {
         if (GetSpline())
         {
@@ -78,22 +78,22 @@ public:
         }
     }
 
-    int GetNumKeys() const
+    int GetNumKeys() const override
     {
         return m_spline->num_keys();
     }
 
-    void SetNumKeys(int numKeys)
+    void SetNumKeys(int numKeys) override
     {
         m_spline->resize(numKeys);
     }
 
-    bool HasKeys() const
+    bool HasKeys() const override
     {
         return GetNumKeys() != 0;
     }
 
-    void RemoveKey(int num)
+    void RemoveKey(int num) override
     {
         if (m_spline && m_spline->num_keys() > num)
         {
@@ -105,7 +105,7 @@ public:
         }
     }
 
-    void GetKey(int index, IKey* key) const
+    void GetKey(int index, IKey* key) const override
     {
         assert(index >= 0 && index < GetNumKeys());
         assert(key != 0);
@@ -123,7 +123,7 @@ public:
         tcbkey->SetValue(k.value);
     }
 
-    void SetKey(int index, IKey* key)
+    void SetKey(int index, IKey* key) override
     {
         assert(index >= 0 && index < GetNumKeys());
         assert(key != 0);
@@ -140,76 +140,76 @@ public:
         Invalidate();
     }
 
-    float GetKeyTime(int index) const
+    float GetKeyTime(int index) const override
     {
         assert(index >= 0 && index < GetNumKeys());
         return m_spline->time(index);
     }
-    void SetKeyTime(int index, float time)
+    void SetKeyTime(int index, float time) override
     {
         assert(index >= 0 && index < GetNumKeys());
         m_spline->SetKeyTime(index, time);
         Invalidate();
     }
-    int GetKeyFlags(int index)
+    int GetKeyFlags(int index) override
     {
         assert(index >= 0 && index < GetNumKeys());
         return m_spline->key(index).flags;
     }
-    void SetKeyFlags(int index, int flags)
+    void SetKeyFlags(int index, int flags) override
     {
         assert(index >= 0 && index < GetNumKeys());
         m_spline->key(index).flags = flags;
     }
 
-    virtual EUiAnimCurveType GetCurveType() { assert(0); return eUiAnimCurveType_Unknown; }
-    virtual EUiAnimValue GetValueType() { assert(0); return eUiAnimValue_Unknown; }
+    EUiAnimCurveType GetCurveType() override { assert(0); return eUiAnimCurveType_Unknown; }
+    EUiAnimValue GetValueType() override { assert(0); return eUiAnimValue_Unknown; }
 
-    virtual void GetValue(float time, float& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec3& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec4& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Quat& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector2& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector3& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector4& value) { assert(0); }
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Color& value) { assert(0); }
+    void GetValue(float time, float& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec3& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec4& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Quat& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector2& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector3& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector4& value) override { assert(0); }
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Color& value) override { assert(0); }
 
-    virtual void SetValue(float time, const float& value, bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec3& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec4& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Quat& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector2& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector3& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector4& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Color& value, [[maybe_unused]] bool bDefault = false) { assert(0); }
+    void SetValue(float time, const float& value, bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec3& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec4& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Quat& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector2& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector3& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector4& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Color& value, [[maybe_unused]] bool bDefault = false) override { assert(0); }
 
-    virtual void OffsetKeyPosition([[maybe_unused]] const Vec3& value) { assert(0); };
+    void OffsetKeyPosition([[maybe_unused]] const Vec3& value) override { assert(0); };
 
-    bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks);
-    bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected, float fTimeOffset);
+    bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks) override;
+    bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected, float fTimeOffset) override;
 
-    void GetKeyInfo(int key, const char*& description, float& duration)
+    void GetKeyInfo(int key, const char*& description, float& duration) override
     {
         description = 0;
         duration = 0;
     }
 
     //! Sort keys in track (after time of keys was modified).
-    void SortKeys()
+    void SortKeys() override
     {
         m_spline->sort_keys();
     };
 
     //! Get track flags.
-    int GetFlags() { return m_flags; }
+    int GetFlags() override { return m_flags; }
 
     //! Check if track is masked by mask
-    virtual bool IsMasked([[maybe_unused]] const uint32 mask) const { return false; }
+    bool IsMasked([[maybe_unused]] const uint32 mask) const override { return false; }
 
     //! Set track flags.
-    void SetFlags(int flags)
+    void SetFlags(int flags) override
     {
         m_flags = flags;
         if (m_flags & eUiAnimTrackFlags_Loop)
@@ -231,12 +231,12 @@ public:
         m_spline->flag_set(Spline::MODIFIED);
     };
 
-    void SetTimeRange(const Range& timeRange)
+    void SetTimeRange(const Range& timeRange) override
     {
         m_spline->SetRange(timeRange.start, timeRange.end);
     }
 
-    int FindKey(float time)
+    int FindKey(float time) override
     {
         // Find key with given time.
         int num = m_spline->num_keys();
@@ -252,7 +252,7 @@ public:
     }
 
     //! Create key at given time, and return its index.
-    int CreateKey(float time)
+    int CreateKey(float time) override
     {
         ValueType value;
 
@@ -272,12 +272,12 @@ public:
         return m_spline->InsertKey(time, tmp);
     }
 
-    int CloneKey(int srcKey)
+    int CloneKey(int srcKey) override
     {
         return CopyKey(this, srcKey);
     }
 
-    int CopyKey(IUiAnimTrack* pFromTrack, int nFromKey)
+    int CopyKey(IUiAnimTrack* pFromTrack, int nFromKey) override
     {
         ITcbKey key;
         pFromTrack->GetKey(nFromKey, &key);
@@ -326,16 +326,16 @@ public:
         m_defaultValue = value;
     }
 
-    virtual ColorB GetCustomColor() const
+    ColorB GetCustomColor() const override
     { return m_customColor; }
-    virtual void SetCustomColor(ColorB color)
+    void SetCustomColor(ColorB color) override
     {
         m_customColor = color;
         m_bCustomColorSet = true;
     }
-    virtual bool HasCustomColor() const
+    bool HasCustomColor() const override
     { return m_bCustomColorSet; }
-    virtual void ClearCustomColor()
+    void ClearCustomColor() override
     { m_bCustomColorSet = false; }
 
     static void Reflect(AZ::SerializeContext* serializeContext) {}
diff --git a/Gems/LyShine/Code/Source/Animation/AnimTrack.h b/Gems/LyShine/Code/Source/Animation/AnimTrack.h
index 9645572e3e..1ab5c26ab0 100644
--- a/Gems/LyShine/Code/Source/Animation/AnimTrack.h
+++ b/Gems/LyShine/Code/Source/Animation/AnimTrack.h
@@ -27,19 +27,19 @@ public:
 
     TUiAnimTrack();
 
-    virtual EUiAnimCurveType GetCurveType() { return eUiAnimCurveType_Unknown; };
-    virtual EUiAnimValue GetValueType() { return eUiAnimValue_Unknown; }
+    EUiAnimCurveType GetCurveType() override { return eUiAnimCurveType_Unknown; };
+    EUiAnimValue GetValueType() override { return eUiAnimValue_Unknown; }
 
-    virtual int GetSubTrackCount() const { return 0; };
-    virtual IUiAnimTrack* GetSubTrack([[maybe_unused]] int nIndex) const { return 0; };
+    int GetSubTrackCount() const override { return 0; };
+    IUiAnimTrack* GetSubTrack([[maybe_unused]] int nIndex) const override { return 0; };
     AZStd::string GetSubTrackName([[maybe_unused]] int nIndex) const override { return AZStd::string(); };
-    virtual void SetSubTrackName([[maybe_unused]] int nIndex, [[maybe_unused]] const char* name) { assert(0); }
+    void SetSubTrackName([[maybe_unused]] int nIndex, [[maybe_unused]] const char* name) override { assert(0); }
 
-    virtual const CUiAnimParamType&  GetParameterType() const { return m_nParamType; };
-    virtual void SetParameterType(CUiAnimParamType type) { m_nParamType = type; };
+    const CUiAnimParamType&  GetParameterType() const override { return m_nParamType; };
+    void SetParameterType(CUiAnimParamType type) override { m_nParamType = type; };
 
-    virtual const UiAnimParamData& GetParamData() const { return m_componentParamData; }
-    virtual void SetParamData(const UiAnimParamData& param) { m_componentParamData = param; }
+    const UiAnimParamData& GetParamData() const override { return m_componentParamData; }
+    void SetParamData(const UiAnimParamData& param) override { m_componentParamData = param; }
 
     //////////////////////////////////////////////////////////////////////////
     // for intrusive_ptr support
@@ -47,7 +47,7 @@ public:
     void release() override;
     //////////////////////////////////////////////////////////////////////////
 
-    virtual bool IsKeySelected(int key) const
+    bool IsKeySelected(int key) const override
     {
         AZ_Assert(key >= 0 && key < (int)m_keys.size(), "Key index is out of range");
         if (m_keys[key].flags & AKEY_SELECTED)
@@ -57,7 +57,7 @@ public:
         return false;
     }
 
-    virtual void SelectKey(int key, bool select)
+    void SelectKey(int key, bool select) override
     {
         AZ_Assert(key >= 0 && key < (int)m_keys.size(), "Key index is out of range");
         if (select)
@@ -71,100 +71,100 @@ public:
     }
 
     //! Return number of keys in track.
-    virtual int GetNumKeys() const { return static_cast<int>(m_keys.size()); };
+    int GetNumKeys() const override { return static_cast<int>(m_keys.size()); };
 
     //! Return true if keys exists in this track
-    virtual bool HasKeys() const { return !m_keys.empty(); }
+    bool HasKeys() const override { return !m_keys.empty(); }
 
     //! Set number of keys in track.
     //! If needed adds empty keys at end or remove keys from end.
-    virtual void SetNumKeys(int numKeys) { m_keys.resize(numKeys); };
+    void SetNumKeys(int numKeys) override { m_keys.resize(numKeys); };
 
     //! Remove specified key.
-    virtual void RemoveKey(int num);
+    void RemoveKey(int num) override;
 
-    int CreateKey(float time);
-    int CloneKey(int fromKey);
-    int CopyKey(IUiAnimTrack* pFromTrack, int nFromKey);
+    int CreateKey(float time) override;
+    int CloneKey(int fromKey) override;
+    int CopyKey(IUiAnimTrack* pFromTrack, int nFromKey) override;
 
     //! Get key at specified location.
     //! @param key Must be valid pointer to compatible key structure, to be filled with specified key location.
-    virtual void GetKey(int index, IKey* key) const;
+    void GetKey(int index, IKey* key) const override;
 
     //! Get time of specified key.
     //! @return key time.
-    virtual float GetKeyTime(int index) const;
+    float GetKeyTime(int index) const override;
 
     //! Find key at given time.
     //! @return Index of found key, or -1 if key with this time not found.
-    virtual int FindKey(float time);
+    int FindKey(float time) override;
 
     //! Get flags of specified key.
     //! @return key time.
-    virtual int GetKeyFlags(int index);
+    int GetKeyFlags(int index) override;
 
     //! Set key at specified location.
     //! @param key Must be valid pointer to compatible key structure.
-    virtual void SetKey(int index, IKey* key);
+    void SetKey(int index, IKey* key) override;
 
     //! Set time of specified key.
-    virtual void SetKeyTime(int index, float time);
+    void SetKeyTime(int index, float time) override;
 
     //! Set flags of specified key.
-    virtual void SetKeyFlags(int index, int flags);
+    void SetKeyFlags(int index, int flags) override;
 
     //! Sort keys in track (after time of keys was modified).
-    virtual void SortKeys();
+    void SortKeys() override;
 
     //! Get track flags.
-    virtual int GetFlags() { return m_flags; }
+    int GetFlags() override { return m_flags; }
 
     //! Check if track is masked
-    virtual bool IsMasked([[maybe_unused]] const uint32 mask) const { return false; }
+    bool IsMasked([[maybe_unused]] const uint32 mask) const override { return false; }
 
     //! Set track flags.
-    virtual void SetFlags(int flags) { m_flags = flags; }
+    void SetFlags(int flags) override { m_flags = flags; }
 
     //////////////////////////////////////////////////////////////////////////
     // Get track value at specified time.
     // Interpolates keys if needed.
     //////////////////////////////////////////////////////////////////////////
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] float& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec3& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec4& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] Quat& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector2& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector3& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector4& value) { assert(0); };
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Color& value) { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] float& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec3& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Vec4& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] Quat& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector2& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector3& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Vector4& value) override { assert(0); };
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] AZ::Color& value) override { assert(0); };
 
     //////////////////////////////////////////////////////////////////////////
     // Set track value at specified time.
     // Adds new keys if required.
     //////////////////////////////////////////////////////////////////////////
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const float& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec3& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec4& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Quat& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector2& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector3& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector4& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Color& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const float& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec3& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Vec4& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const Quat& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector2& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector3& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Vector4& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const AZ::Color& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
 
-    virtual void OffsetKeyPosition([[maybe_unused]] const Vec3& value) { assert(0); };
+    void OffsetKeyPosition([[maybe_unused]] const Vec3& value) override { assert(0); };
 
     /** Assign active time range for this track.
     */
-    virtual void SetTimeRange(const Range& timeRange) { m_timeRange = timeRange; };
+    void SetTimeRange(const Range& timeRange) override { m_timeRange = timeRange; };
 
     /** Serialize this animation track to XML.
             Do not override this method, prefer to override SerializeKey.
     */
-    virtual bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true);
+    bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true) override;
 
-    virtual bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected = false, float fTimeOffset = 0);
+    bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected = false, float fTimeOffset = 0) override;
 
 
     /** Serialize single key of this track.
@@ -181,21 +181,21 @@ public:
     int GetActiveKey(float time, KeyType* key);
 
 #ifdef UI_ANIMATION_SYSTEM_SUPPORT_EDITING
-    virtual ColorB GetCustomColor() const
+    ColorB GetCustomColor() const override
     { return m_customColor; }
-    virtual void SetCustomColor(ColorB color)
+    void SetCustomColor(ColorB color) override
     {
         m_customColor = color;
         m_bCustomColorSet = true;
     }
-    virtual bool HasCustomColor() const
+    bool HasCustomColor() const override
     { return m_bCustomColorSet; }
-    virtual void ClearCustomColor()
+    void ClearCustomColor() override
     { m_bCustomColorSet = false; }
 #endif
 
-    virtual void GetKeyValueRange(float& fMin, float& fMax) const { fMin = m_fMinKeyValue; fMax = m_fMaxKeyValue; };
-    virtual void SetKeyValueRange(float fMin, float fMax){ m_fMinKeyValue = fMin; m_fMaxKeyValue = fMax; };
+    void GetKeyValueRange(float& fMin, float& fMax) const override { fMin = m_fMinKeyValue; fMax = m_fMaxKeyValue; };
+    void SetKeyValueRange(float fMin, float fMax) override{ m_fMinKeyValue = fMin; m_fMaxKeyValue = fMax; };
 
     static void Reflect(AZ::SerializeContext* serializeContext) {}
 
diff --git a/Gems/LyShine/Code/Source/Animation/AzEntityNode.h b/Gems/LyShine/Code/Source/Animation/AzEntityNode.h
index 9771ac7be3..f3a0fd641f 100644
--- a/Gems/LyShine/Code/Source/Animation/AzEntityNode.h
+++ b/Gems/LyShine/Code/Source/Animation/AzEntityNode.h
@@ -37,24 +37,24 @@ public:
 
     void EnableEntityPhysics(bool bEnable);
 
-    virtual EUiAnimNodeType GetType() const { return eUiAnimNodeType_AzEntity; }
+    EUiAnimNodeType GetType() const override { return eUiAnimNodeType_AzEntity; }
 
-    virtual void AddTrack(IUiAnimTrack* track);
+    void AddTrack(IUiAnimTrack* track) override;
 
     //////////////////////////////////////////////////////////////////////////
     // Overrides from CUiAnimNode
     //////////////////////////////////////////////////////////////////////////
 
     // UiAnimNodeInterface
-    virtual AZ::EntityId GetAzEntityId() override { return m_entityId; };
-    virtual void SetAzEntity(AZ::Entity* entity) override { m_entityId = entity->GetId(); }
+    AZ::EntityId GetAzEntityId() override { return m_entityId; };
+    void SetAzEntity(AZ::Entity* entity) override { m_entityId = entity->GetId(); }
     // ~UiAnimNodeInterface
 
 
-    virtual void StillUpdate();
-    virtual void Animate(SUiAnimContext& ec);
+    void StillUpdate() override;
+    void Animate(SUiAnimContext& ec) override;
 
-    virtual void CreateDefaultTracks();
+    void CreateDefaultTracks() override;
 
     bool SetParamValueAz(float time, const UiAnimParamData& param, float value) override;
     bool SetParamValueAz(float time, const UiAnimParamData& param, bool value) override;
@@ -67,30 +67,30 @@ public:
 
     bool GetParamValueAz(float time, const UiAnimParamData& param, float& value) override;
 
-    virtual void PrecacheStatic(float startTime) override;
-    virtual void PrecacheDynamic(float time) override;
+    void PrecacheStatic(float startTime) override;
+    void PrecacheDynamic(float time) override;
 
     Vec3 GetPos() { return m_pos; };
     Quat GetRotate() { return m_rotate; };
     Vec3 GetScale() { return m_scale; };
 
-    virtual void Activate(bool bActivate);
+    void Activate(bool bActivate) override;
 
     IUiAnimTrack* GetTrackForAzField(const UiAnimParamData& param) const override;
     IUiAnimTrack* CreateTrackForAzField(const UiAnimParamData& param) override;
 
     //////////////////////////////////////////////////////////////////////////
-    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks);
-    virtual void InitPostLoad(IUiAnimSequence* pSequence, bool remapIds, LyShine::EntityIdMap* entityIdMap);
-    void OnReset();
-    void OnResetHard();
-    void OnStart();
-    void OnPause();
-    void OnStop();
+    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks) override;
+    void InitPostLoad(IUiAnimSequence* pSequence, bool remapIds, LyShine::EntityIdMap* entityIdMap) override;
+    void OnReset() override;
+    void OnResetHard() override;
+    void OnStart() override;
+    void OnPause() override;
+    void OnStop() override;
 
     //////////////////////////////////////////////////////////////////////////
-    virtual unsigned int GetParamCount() const;
-    virtual CUiAnimParamType GetParamType(unsigned int nIndex) const;
+    unsigned int GetParamCount() const override;
+    CUiAnimParamType GetParamType(unsigned int nIndex) const override;
     AZStd::string GetParamName(const CUiAnimParamType& param) const override;
     AZStd::string GetParamNameForTrack(const CUiAnimParamType& param, const IUiAnimTrack* track) const override;
 
@@ -100,7 +100,7 @@ public:
     static void Reflect(AZ::SerializeContext* serializeContext);
 
 protected:
-    virtual bool GetParamInfoFromType(const CUiAnimParamType& paramId, SParamInfo& info) const;
+    bool GetParamInfoFromType(const CUiAnimParamType& paramId, SParamInfo& info) const override;
 
     //! Given the class data definition and a track for a field within it,
     //! compute the offset for the field and set it in the track
@@ -115,7 +115,7 @@ protected:
     void ReleaseSounds();
 
     // functions involved in the process to parse and store lua animated properties
-    virtual void UpdateDynamicParams();
+    void UpdateDynamicParams() override;
     virtual void UpdateDynamicParams_Editor();
     virtual void UpdateDynamicParams_PureGame();
 
diff --git a/Gems/LyShine/Code/Source/Animation/CompoundSplineTrack.h b/Gems/LyShine/Code/Source/Animation/CompoundSplineTrack.h
index 127b6593fb..83a1f82588 100644
--- a/Gems/LyShine/Code/Source/Animation/CompoundSplineTrack.h
+++ b/Gems/LyShine/Code/Source/Animation/CompoundSplineTrack.h
@@ -26,8 +26,8 @@ public:
     UiCompoundSplineTrack(int nDims, EUiAnimValue inValueType, CUiAnimParamType subTrackParamTypes[MAX_SUBTRACKS]);
     UiCompoundSplineTrack();
 
-    void add_ref() { ++m_refCount; }
-    void release()
+    void add_ref() override { ++m_refCount; }
+    void release() override
     {
         if (--m_refCount <= 0)
         {
@@ -35,107 +35,107 @@ public:
         }
     }
 
-    virtual int GetSubTrackCount() const { return m_nDimensions; };
-    virtual IUiAnimTrack* GetSubTrack(int nIndex) const;
+    int GetSubTrackCount() const override { return m_nDimensions; };
+    IUiAnimTrack* GetSubTrack(int nIndex) const override;
     AZStd::string GetSubTrackName(int nIndex) const override;
-    virtual void SetSubTrackName(int nIndex, const char* name);
+    void SetSubTrackName(int nIndex, const char* name) override;
 
-    virtual EUiAnimCurveType GetCurveType() { return eUiAnimCurveType_BezierFloat; };
-    virtual EUiAnimValue GetValueType() { return m_valueType; };
+    EUiAnimCurveType GetCurveType() override { return eUiAnimCurveType_BezierFloat; };
+    EUiAnimValue GetValueType() override { return m_valueType; };
 
-    virtual const CUiAnimParamType& GetParameterType() const { return m_nParamType; };
-    virtual void SetParameterType(CUiAnimParamType type) { m_nParamType = type; }
+    const CUiAnimParamType& GetParameterType() const override { return m_nParamType; };
+    void SetParameterType(CUiAnimParamType type) override { m_nParamType = type; }
 
-    virtual const UiAnimParamData& GetParamData() const { return m_componentParamData; }
-    virtual void SetParamData(const UiAnimParamData& param) { m_componentParamData = param; }
+    const UiAnimParamData& GetParamData() const override { return m_componentParamData; }
+    void SetParamData(const UiAnimParamData& param) override { m_componentParamData = param; }
 
-    virtual int GetNumKeys() const;
-    virtual void SetNumKeys([[maybe_unused]] int numKeys) { assert(0); };
-    virtual bool HasKeys() const;
-    virtual void RemoveKey(int num);
+    int GetNumKeys() const override;
+    void SetNumKeys([[maybe_unused]] int numKeys) override { assert(0); };
+    bool HasKeys() const override;
+    void RemoveKey(int num) override;
 
-    virtual void GetKeyInfo(int key, const char*& description, float& duration);
-    virtual int CreateKey([[maybe_unused]] float time) { assert(0); return 0; };
-    virtual int CloneKey([[maybe_unused]] int fromKey) { assert(0); return 0; };
-    virtual int CopyKey([[maybe_unused]] IUiAnimTrack* pFromTrack, [[maybe_unused]] int nFromKey) { assert(0); return 0; };
-    virtual void GetKey([[maybe_unused]] int index, [[maybe_unused]] IKey* key) const { assert(0); };
-    virtual float GetKeyTime(int index) const;
-    virtual int FindKey([[maybe_unused]] float time) { assert(0); return 0; };
-    virtual int GetKeyFlags([[maybe_unused]] int index) { assert(0); return 0; };
-    virtual void SetKey([[maybe_unused]] int index, [[maybe_unused]] IKey* key) { assert(0); };
-    virtual void SetKeyTime(int index, float time);
-    virtual void SetKeyFlags([[maybe_unused]] int index, [[maybe_unused]] int flags) { assert(0); };
-    virtual void SortKeys() { assert(0); };
+    void GetKeyInfo(int key, const char*& description, float& duration) override;
+    int CreateKey([[maybe_unused]] float time) override { assert(0); return 0; };
+    int CloneKey([[maybe_unused]] int fromKey) override { assert(0); return 0; };
+    int CopyKey([[maybe_unused]] IUiAnimTrack* pFromTrack, [[maybe_unused]] int nFromKey) override { assert(0); return 0; };
+    void GetKey([[maybe_unused]] int index, [[maybe_unused]] IKey* key) const override { assert(0); };
+    float GetKeyTime(int index) const override;
+    int FindKey([[maybe_unused]] float time) override { assert(0); return 0; };
+    int GetKeyFlags([[maybe_unused]] int index) override { assert(0); return 0; };
+    void SetKey([[maybe_unused]] int index, [[maybe_unused]] IKey* key) override { assert(0); };
+    void SetKeyTime(int index, float time) override;
+    void SetKeyFlags([[maybe_unused]] int index, [[maybe_unused]] int flags) override { assert(0); };
+    void SortKeys() override { assert(0); };
 
-    virtual bool IsKeySelected(int key) const;
-    virtual void SelectKey(int key, bool select);
+    bool IsKeySelected(int key) const override;
+    void SelectKey(int key, bool select) override;
 
-    virtual int GetFlags() { return m_flags; };
-    virtual bool IsMasked([[maybe_unused]] const uint32 mask) const { return false; }
-    virtual void SetFlags(int flags) { m_flags = flags; };
+    int GetFlags() override { return m_flags; };
+    bool IsMasked([[maybe_unused]] const uint32 mask) const override { return false; }
+    void SetFlags(int flags) override { m_flags = flags; };
 
     //////////////////////////////////////////////////////////////////////////
     // Get track value at specified time.
     // Interpolates keys if needed.
     //////////////////////////////////////////////////////////////////////////
-    virtual void GetValue(float time, float& value);
-    virtual void GetValue(float time, Vec3& value);
-    virtual void GetValue(float time, Vec4& value);
-    virtual void GetValue(float time, Quat& value);
-    virtual void GetValue(float time, AZ::Vector2& value);
-    virtual void GetValue(float time, AZ::Vector3& value);
-    virtual void GetValue(float time, AZ::Vector4& value);
-    virtual void GetValue(float time, AZ::Color& value);
-    virtual void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) { assert(0); };
+    void GetValue(float time, float& value) override;
+    void GetValue(float time, Vec3& value) override;
+    void GetValue(float time, Vec4& value) override;
+    void GetValue(float time, Quat& value) override;
+    void GetValue(float time, AZ::Vector2& value) override;
+    void GetValue(float time, AZ::Vector3& value) override;
+    void GetValue(float time, AZ::Vector4& value) override;
+    void GetValue(float time, AZ::Color& value) override;
+    void GetValue([[maybe_unused]] float time, [[maybe_unused]] bool& value) override { assert(0); };
 
     //////////////////////////////////////////////////////////////////////////
     // Set track value at specified time.
     // Adds new keys if required.
     //////////////////////////////////////////////////////////////////////////
-    virtual void SetValue(float time, const float& value, bool bDefault = false);
-    virtual void SetValue(float time, const Vec3& value, bool bDefault = false);
-    void SetValue(float time, const Vec4& value, bool bDefault = false);
-    virtual void SetValue(float time, const Quat& value, bool bDefault = false);
-    virtual void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) { assert(0); };
-    virtual void SetValue(float time, const AZ::Vector2& value, bool bDefault = false);
-    virtual void SetValue(float time, const AZ::Vector3& value, bool bDefault = false);
-    virtual void SetValue(float time, const AZ::Vector4& value, bool bDefault = false);
-    virtual void SetValue(float time, const AZ::Color& value, bool bDefault = false);
+    void SetValue(float time, const float& value, bool bDefault = false) override;
+    void SetValue(float time, const Vec3& value, bool bDefault = false) override;
+    void SetValue(float time, const Vec4& value, bool bDefault = false) override;
+    void SetValue(float time, const Quat& value, bool bDefault = false) override;
+    void SetValue([[maybe_unused]] float time, [[maybe_unused]] const bool& value, [[maybe_unused]] bool bDefault = false) override { assert(0); };
+    void SetValue(float time, const AZ::Vector2& value, bool bDefault = false) override;
+    void SetValue(float time, const AZ::Vector3& value, bool bDefault = false) override;
+    void SetValue(float time, const AZ::Vector4& value, bool bDefault = false) override;
+    void SetValue(float time, const AZ::Color& value, bool bDefault = false) override;
 
-    virtual void OffsetKeyPosition(const Vec3& value);
+    void OffsetKeyPosition(const Vec3& value) override;
 
-    virtual void SetTimeRange(const Range& timeRange);
+    void SetTimeRange(const Range& timeRange) override;
 
-    virtual bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true);
+    bool Serialize(IUiAnimationSystem* uiAnimationSystem, XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks = true) override;
 
-    virtual bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected = false, float fTimeOffset = 0);
+    bool SerializeSelection(XmlNodeRef& xmlNode, bool bLoading, bool bCopySelected = false, float fTimeOffset = 0) override;
 
-    virtual int NextKeyByTime(int key) const;
+    int NextKeyByTime(int key) const override;
 
     void SetSubTrackName(const int i, const AZStd::string& name) { assert (i < MAX_SUBTRACKS); m_subTrackNames[i] = name; }
 
 #ifdef UI_ANIMATION_SYSTEM_SUPPORT_EDITING
-    virtual ColorB GetCustomColor() const
+    ColorB GetCustomColor() const override
     { return m_customColor; }
-    virtual void SetCustomColor(ColorB color)
+    void SetCustomColor(ColorB color) override
     {
         m_customColor = color;
         m_bCustomColorSet = true;
     }
-    virtual bool HasCustomColor() const
+    bool HasCustomColor() const override
     { return m_bCustomColorSet; }
-    virtual void ClearCustomColor()
+    void ClearCustomColor() override
     { m_bCustomColorSet = false; }
 #endif
 
-    virtual void GetKeyValueRange(float& fMin, float& fMax) const
+    void GetKeyValueRange(float& fMin, float& fMax) const override
     {
         if (GetSubTrackCount() > 0)
         {
             m_subTracks[0]->GetKeyValueRange(fMin, fMax);
         }
     };
-    virtual void SetKeyValueRange(float fMin, float fMax)
+    void SetKeyValueRange(float fMin, float fMax) override
     {
         for (int i = 0; i < m_nDimensions; ++i)
         {
diff --git a/Gems/LyShine/Code/Source/Animation/TrackEventTrack.h b/Gems/LyShine/Code/Source/Animation/TrackEventTrack.h
index 5896b19a2a..c7499c15d0 100644
--- a/Gems/LyShine/Code/Source/Animation/TrackEventTrack.h
+++ b/Gems/LyShine/Code/Source/Animation/TrackEventTrack.h
@@ -66,9 +66,9 @@ public:
     //////////////////////////////////////////////////////////////////////////
     // Overrides of IAnimTrack.
     //////////////////////////////////////////////////////////////////////////
-    void GetKeyInfo(int key, const char*& description, float& duration);
-    void SerializeKey(IEventKey& key, XmlNodeRef& keyNode, bool bLoading);
-    void SetKey(int index, IKey* key);
+    void GetKeyInfo(int key, const char*& description, float& duration) override;
+    void SerializeKey(IEventKey& key, XmlNodeRef& keyNode, bool bLoading) override;
+    void SetKey(int index, IKey* key) override;
     void InitPostLoad(IUiAnimSequence* sequence) override;
 
     static void Reflect(AZ::SerializeContext* serializeContext);
diff --git a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
index c1dbdcfcda..c270d9ca60 100644
--- a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
+++ b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
@@ -44,94 +44,94 @@ public:
 
     ~UiAnimationSystem();
 
-    void Release() { delete this; };
+    void Release() override { delete this; };
 
-    bool Load(const char* pszFile, const char* pszMission);
+    bool Load(const char* pszFile, const char* pszMission) override;
 
-    ISystem* GetSystem() { return m_pSystem; }
+    ISystem* GetSystem() override { return m_pSystem; }
 
-    IUiAnimTrack* CreateTrack(EUiAnimCurveType type);
+    IUiAnimTrack* CreateTrack(EUiAnimCurveType type) override;
 
-    IUiAnimSequence* CreateSequence(const char* sequence, bool bLoad = false, uint32 id = 0);
+    IUiAnimSequence* CreateSequence(const char* sequence, bool bLoad = false, uint32 id = 0) override;
     IUiAnimSequence* LoadSequence(const char* pszFilePath);
-    IUiAnimSequence* LoadSequence(XmlNodeRef& xmlNode, bool bLoadEmpty = true);
+    IUiAnimSequence* LoadSequence(XmlNodeRef& xmlNode, bool bLoadEmpty = true) override;
 
-    void AddSequence(IUiAnimSequence* pSequence);
-    void RemoveSequence(IUiAnimSequence* pSequence);
-    IUiAnimSequence* FindSequence(const char* sequence) const;
-    IUiAnimSequence* FindSequenceById(uint32 id) const;
-    IUiAnimSequence* GetSequence(int i) const;
-    int GetNumSequences() const;
-    IUiAnimSequence* GetPlayingSequence(int i) const;
-    int GetNumPlayingSequences() const;
-    bool IsCutScenePlaying() const;
+    void AddSequence(IUiAnimSequence* pSequence) override;
+    void RemoveSequence(IUiAnimSequence* pSequence) override;
+    IUiAnimSequence* FindSequence(const char* sequence) const override;
+    IUiAnimSequence* FindSequenceById(uint32 id) const override;
+    IUiAnimSequence* GetSequence(int i) const override;
+    int GetNumSequences() const override;
+    IUiAnimSequence* GetPlayingSequence(int i) const override;
+    int GetNumPlayingSequences() const override;
+    bool IsCutScenePlaying() const override;
 
-    uint32 GrabNextSequenceId()
+    uint32 GrabNextSequenceId() override
     { return m_nextSequenceId++; }
 
-    int OnSequenceRenamed(const char* before, const char* after);
-    int OnCameraRenamed(const char* before, const char* after);
+    int OnSequenceRenamed(const char* before, const char* after) override;
+    int OnCameraRenamed(const char* before, const char* after) override;
 
-    bool AddUiAnimationListener(IUiAnimSequence* pSequence, IUiAnimationListener* pListener);
-    bool RemoveUiAnimationListener(IUiAnimSequence* pSequence, IUiAnimationListener* pListener);
+    bool AddUiAnimationListener(IUiAnimSequence* pSequence, IUiAnimationListener* pListener) override;
+    bool RemoveUiAnimationListener(IUiAnimSequence* pSequence, IUiAnimationListener* pListener) override;
 
-    void RemoveAllSequences();
+    void RemoveAllSequences() override;
 
     //////////////////////////////////////////////////////////////////////////
     // Sequence playback.
     //////////////////////////////////////////////////////////////////////////
     void PlaySequence(const char* sequence, IUiAnimSequence* parentSeq = NULL, bool bResetFX = true,
-        bool bTrackedSequence = false, float startTime = -FLT_MAX, float endTime = -FLT_MAX);
+        bool bTrackedSequence = false, float startTime = -FLT_MAX, float endTime = -FLT_MAX) override;
     void PlaySequence(IUiAnimSequence* seq, IUiAnimSequence* parentSeq = NULL, bool bResetFX = true,
-        bool bTrackedSequence = false, float startTime = -FLT_MAX, float endTime = -FLT_MAX);
-    void PlayOnLoadSequences();
+        bool bTrackedSequence = false, float startTime = -FLT_MAX, float endTime = -FLT_MAX) override;
+    void PlayOnLoadSequences() override;
 
-    bool StopSequence(const char* sequence);
-    bool StopSequence(IUiAnimSequence* seq);
-    bool AbortSequence(IUiAnimSequence* seq, bool bLeaveTime = false);
+    bool StopSequence(const char* sequence) override;
+    bool StopSequence(IUiAnimSequence* seq) override;
+    bool AbortSequence(IUiAnimSequence* seq, bool bLeaveTime = false) override;
 
-    void StopAllSequences();
-    void StopAllCutScenes();
+    void StopAllSequences() override;
+    void StopAllCutScenes() override;
     void Pause(bool bPause);
 
-    void Reset(bool bPlayOnReset, bool bSeekToStart);
-    void StillUpdate();
-    void PreUpdate(const float dt);
-    void PostUpdate(const float dt);
-    void Render();
+    void Reset(bool bPlayOnReset, bool bSeekToStart) override;
+    void StillUpdate() override;
+    void PreUpdate(const float dt) override;
+    void PostUpdate(const float dt) override;
+    void Render() override;
 
-    bool IsPlaying(IUiAnimSequence* seq) const;
+    bool IsPlaying(IUiAnimSequence* seq) const override;
 
-    void Pause();
-    void Resume();
+    void Pause() override;
+    void Resume() override;
 
-    void SetRecording(bool recording) { m_bRecording = recording; };
-    bool IsRecording() const { return m_bRecording; };
+    void SetRecording(bool recording) override { m_bRecording = recording; };
+    bool IsRecording() const override { return m_bRecording; };
 
-    void SetCallback(IUiAnimationCallback* pCallback) { m_pCallback = pCallback; }
-    IUiAnimationCallback* GetCallback() { return m_pCallback; }
+    void SetCallback(IUiAnimationCallback* pCallback) override { m_pCallback = pCallback; }
+    IUiAnimationCallback* GetCallback() override { return m_pCallback; }
     void Callback(IUiAnimationCallback::ECallbackReason Reason, IUiAnimNode* pNode);
 
-    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bRemoveOldNodes = false, bool bLoadEmpty = true);
-    void InitPostLoad(bool remapIds, LyShine::EntityIdMap* entityIdMap);
+    void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bRemoveOldNodes = false, bool bLoadEmpty = true) override;
+    void InitPostLoad(bool remapIds, LyShine::EntityIdMap* entityIdMap) override;
 
-    void SetSequenceStopBehavior(ESequenceStopBehavior behavior);
-    IUiAnimationSystem::ESequenceStopBehavior GetSequenceStopBehavior();
+    void SetSequenceStopBehavior(ESequenceStopBehavior behavior) override;
+    IUiAnimationSystem::ESequenceStopBehavior GetSequenceStopBehavior() override;
 
-    float GetPlayingTime(IUiAnimSequence* pSeq);
-    bool SetPlayingTime(IUiAnimSequence* pSeq, float fTime);
+    float GetPlayingTime(IUiAnimSequence* pSeq) override;
+    bool SetPlayingTime(IUiAnimSequence* pSeq, float fTime) override;
 
-    float GetPlayingSpeed(IUiAnimSequence* pSeq);
-    bool SetPlayingSpeed(IUiAnimSequence* pSeq, float fTime);
+    float GetPlayingSpeed(IUiAnimSequence* pSeq) override;
+    bool SetPlayingSpeed(IUiAnimSequence* pSeq, float fTime) override;
 
-    bool GetStartEndTime(IUiAnimSequence* pSeq, float& fStartTime, float& fEndTime);
-    bool SetStartEndTime(IUiAnimSequence* pSeq, const float fStartTime, const float fEndTime);
+    bool GetStartEndTime(IUiAnimSequence* pSeq, float& fStartTime, float& fEndTime) override;
+    bool SetStartEndTime(IUiAnimSequence* pSeq, const float fStartTime, const float fEndTime) override;
 
-    void GoToFrame(const char* seqName, float targetFrame);
+    void GoToFrame(const char* seqName, float targetFrame) override;
 
     void SerializeNodeType(EUiAnimNodeType& animNodeType, XmlNodeRef& xmlNode, bool bLoading, const uint version, int flags);
-    virtual void SerializeParamType(CUiAnimParamType& animParamType, XmlNodeRef& xmlNode, bool bLoading, const uint version);
-    virtual void SerializeParamData(UiAnimParamData& animParamData, XmlNodeRef& xmlNode, bool bLoading);
+    void SerializeParamType(CUiAnimParamType& animParamType, XmlNodeRef& xmlNode, bool bLoading, const uint version) override;
+    void SerializeParamData(UiAnimParamData& animParamData, XmlNodeRef& xmlNode, bool bLoading) override;
 
     static const char* GetParamTypeName(const CUiAnimParamType& animParamType);
 
@@ -156,8 +156,8 @@ private:
     void UpdateInternal(const float dt, const bool bPreUpdate);
 
 #ifdef UI_ANIMATION_SYSTEM_SUPPORT_EDITING
-    virtual EUiAnimNodeType GetNodeTypeFromString(const char* pString) const;
-    virtual CUiAnimParamType GetParamTypeFromString(const char* pString) const;
+    EUiAnimNodeType GetNodeTypeFromString(const char* pString) const override;
+    CUiAnimParamType GetParamTypeFromString(const char* pString) const override;
 #endif
 
     ISystem* m_pSystem;
diff --git a/Gems/LyShine/Code/Source/LyShineSystemComponent.h b/Gems/LyShine/Code/Source/LyShineSystemComponent.h
index 3d5e81f7c5..5b4086007b 100644
--- a/Gems/LyShine/Code/Source/LyShineSystemComponent.h
+++ b/Gems/LyShine/Code/Source/LyShineSystemComponent.h
@@ -65,7 +65,7 @@ namespace LyShine
         // UiSystemBus interface implementation
         void RegisterComponentTypeForMenuOrdering(const AZ::Uuid& typeUuid) override;
         const AZStd::vector<AZ::Uuid>* GetComponentTypesForMenuOrdering() override;
-        const AZStd::list<AZ::ComponentDescriptor*>* GetLyShineComponentDescriptors();
+        const AZStd::list<AZ::ComponentDescriptor*>* GetLyShineComponentDescriptors() override;
         ////////////////////////////////////////////////////////////////////////
 
         ////////////////////////////////////////////////////////////////////////
@@ -89,7 +89,7 @@ namespace LyShine
 
         // CrySystemEventBus ///////////////////////////////////////////////////////
         void OnCrySystemInitialized(ISystem& system, const SSystemInitParams&) override;
-        virtual void OnCrySystemShutdown(ISystem&) override;
+        void OnCrySystemShutdown(ISystem&) override;
         ////////////////////////////////////////////////////////////////////////////
 
         void BroadcastCursorImagePathname();
diff --git a/Gems/LyShine/Code/Source/UiLayoutFitterComponent.h b/Gems/LyShine/Code/Source/UiLayoutFitterComponent.h
index d8ca9462bc..c5ceef4a74 100644
--- a/Gems/LyShine/Code/Source/UiLayoutFitterComponent.h
+++ b/Gems/LyShine/Code/Source/UiLayoutFitterComponent.h
@@ -72,7 +72,7 @@ protected: // member functions
     // ~AZ::Component
 
     // UiLayoutControllerInterface
-    unsigned int GetPriority() const;
+    unsigned int GetPriority() const override;
     // ~UiLayoutControllerInterface
 
     AZ_DISABLE_COPY_MOVE(UiLayoutFitterComponent);
diff --git a/Gems/LyShine/Code/Source/UiScrollBarComponent.h b/Gems/LyShine/Code/Source/UiScrollBarComponent.h
index 78bfa708c7..ba7abdf5e5 100644
--- a/Gems/LyShine/Code/Source/UiScrollBarComponent.h
+++ b/Gems/LyShine/Code/Source/UiScrollBarComponent.h
@@ -53,7 +53,7 @@ public: // member functions
 
     // UiScrollerInterface
     Orientation GetOrientation() override;
-    void SetOrientation(Orientation orientation);
+    void SetOrientation(Orientation orientation) override;
     AZ::EntityId GetScrollableEntity() override;
     void SetScrollableEntity(AZ::EntityId entityId) override;
     float GetValue() override;
diff --git a/Gems/LyShine/Code/Source/UiTooltipDisplayComponent.h b/Gems/LyShine/Code/Source/UiTooltipDisplayComponent.h
index 7aa0c0f618..d1fd53ec28 100644
--- a/Gems/LyShine/Code/Source/UiTooltipDisplayComponent.h
+++ b/Gems/LyShine/Code/Source/UiTooltipDisplayComponent.h
@@ -70,7 +70,7 @@ public: // member functions
     // ~UiInitializationInterface
 
     //! IUiAnimationListener
-    void OnUiAnimationEvent(EUiAnimationEvent uiAnimationEvent, IUiAnimSequence* pAnimSequence);
+    void OnUiAnimationEvent(EUiAnimationEvent uiAnimationEvent, IUiAnimSequence* pAnimSequence) override;
     // ~IUiAnimationListener
 
     State GetState();