Code/Editor

Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>

Code/Editor/2DViewport.h

@@ -35,32 +35,32 @@ public:
     Q2DViewport(QWidget* parent = nullptr);
     virtual ~Q2DViewport();
 
-    virtual void SetType(EViewportType type);
-    virtual EViewportType GetType() const { return m_viewType; }
-    virtual float GetAspectRatio() const { return 1.0f; };
+    void SetType(EViewportType type) override;
+    EViewportType GetType() const override { return m_viewType; }
+    float GetAspectRatio() const override { return 1.0f; };
 
-    virtual void ResetContent();
-    virtual void UpdateContent(int flags);
+    void ResetContent() override;
+    void UpdateContent(int flags) override;
 
 public slots:
     // Called every frame to update viewport.
-    virtual void Update();
+    void Update() override;
 
 public:
     //! Map world space position to viewport position.
-    virtual QPoint     WorldToView(const Vec3& wp) const;
+    QPoint     WorldToView(const Vec3& wp) const override;
 
-    virtual QPoint WorldToViewParticleEditor(const Vec3& wp, int width, int height) const; //Eric@conffx
+    QPoint WorldToViewParticleEditor(const Vec3& wp, int width, int height) const override; //Eric@conffx
 
     //! Map viewport position to world space position.
-    virtual Vec3        ViewToWorld(const QPoint& vp, bool* collideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const override;
+    Vec3        ViewToWorld(const QPoint& vp, bool* collideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const override;
     //! Map viewport position to world space ray from camera.
-    virtual void        ViewToWorldRay(const QPoint& vp, Vec3& raySrc, Vec3& rayDir) const;
+    void        ViewToWorldRay(const QPoint& vp, Vec3& raySrc, Vec3& rayDir) const override;
 
     void OnTitleMenu(QMenu* menu) override;
 
-    virtual bool HitTest(const QPoint& point, HitContext& hitInfo) override;
-    virtual bool IsBoundsVisible(const AABB& box) const;
+    bool HitTest(const QPoint& point, HitContext& hitInfo) override;
+    bool IsBoundsVisible(const AABB& box) const override;
 
     // ovverided from CViewport.
     float GetScreenScaleFactor(const Vec3& worldPoint) const override;
@@ -111,8 +111,8 @@ protected:
     virtual void SetZoom(float fZoomFactor, const QPoint& center);
 
     // overrides from CViewport.
-    virtual void MakeConstructionPlane(int axis);
-    virtual const Matrix34& GetConstructionMatrix(RefCoordSys coordSys);
+    void MakeConstructionPlane(int axis) override;
+    const Matrix34& GetConstructionMatrix(RefCoordSys coordSys) override;
 
     //! Calculate view transformation matrix.
     virtual void CalculateViewTM();
@@ -146,9 +146,9 @@ protected:
     void showEvent(QShowEvent* event) override;
     void paintEvent(QPaintEvent* event) override;
     int OnCreate();
-    void OnRButtonDown(Qt::KeyboardModifiers modifiers, const QPoint& point);
-    void OnRButtonUp(Qt::KeyboardModifiers modifiers, const QPoint& point);
-    void OnMouseWheel(Qt::KeyboardModifiers modifiers, short zDelta, const QPoint& pt);
+    void OnRButtonDown(Qt::KeyboardModifiers modifiers, const QPoint& point) override;
+    void OnRButtonUp(Qt::KeyboardModifiers modifiers, const QPoint& point) override;
+    void OnMouseWheel(Qt::KeyboardModifiers modifiers, short zDelta, const QPoint& pt) override;
     void OnDestroy();
 
 protected:

Code/Editor/ActionManager.h

@@ -353,7 +353,7 @@ public:
         m_actionHandlers[id] = std::bind(method, object, id);
     }
 
-    bool eventFilter(QObject* watched, QEvent* event);
+    bool eventFilter(QObject* watched, QEvent* event) override;
 
     // returns false if the action was already inserted, indicating that the action should not be processed again
     bool InsertActionExecuting(int id);

Code/Editor/AnimationContext.h

@@ -197,7 +197,7 @@ private:
 
     virtual void OnSequenceRemoved(CTrackViewSequence* pSequence) override;
 
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
+    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     void AnimateActiveSequence();
 

Code/Editor/BaseLibrary.h

@@ -40,57 +40,57 @@ public:
     //! Set library name.
     virtual void SetName(const QString& name);
     //! Get library name.
-    const QString& GetName() const;
+    const QString& GetName() const override;
 
     //! Set new filename for this library.
     virtual bool SetFilename(const QString& filename, [[maybe_unused]] bool checkForUnique = true) { m_filename = filename.toLower(); return true; };
-    const QString& GetFilename() const { return m_filename; };
+    const QString& GetFilename() const override { return m_filename; };
 
-    virtual bool Save() = 0;
-    virtual bool Load(const QString& filename) = 0;
-    virtual void Serialize(XmlNodeRef& node, bool bLoading) = 0;
+    bool Save() override = 0;
+    bool Load(const QString& filename) override = 0;
+    void Serialize(XmlNodeRef& node, bool bLoading) override = 0;
 
     //! Mark library as modified.
-    void SetModified(bool bModified = true);
+    void SetModified(bool bModified = true) override;
     //! Check if library was modified.
-    bool IsModified() const { return m_bModified; };
+    bool IsModified() const override { return m_bModified; };
 
     //////////////////////////////////////////////////////////////////////////
     // Working with items.
     //////////////////////////////////////////////////////////////////////////
     //! Add a new prototype to library.
-    void AddItem(IDataBaseItem* item, bool bRegister = true);
+    void AddItem(IDataBaseItem* item, bool bRegister = true) override;
     //! Get number of known prototypes.
-    int GetItemCount() const { return static_cast<int>(m_items.size()); }
+    int GetItemCount() const override { return static_cast<int>(m_items.size()); }
     //! Get prototype by index.
-    IDataBaseItem* GetItem(int index);
+    IDataBaseItem* GetItem(int index) override;
 
     //! Delete item by pointer of item.
-    void RemoveItem(IDataBaseItem* item);
+    void RemoveItem(IDataBaseItem* item) override;
 
     //! Delete all items from library.
-    void RemoveAllItems();
+    void RemoveAllItems() override;
 
     //! Find library item by name.
     //! Using linear search.
-    IDataBaseItem* FindItem(const QString& name);
+    IDataBaseItem* FindItem(const QString& name) override;
 
     //! Check if this library is local level library.
-    bool IsLevelLibrary() const { return m_bLevelLib; };
+    bool IsLevelLibrary() const override { return m_bLevelLib; };
 
     //! Set library to be level library.
-    void SetLevelLibrary(bool bEnable) { m_bLevelLib = bEnable; };
+    void SetLevelLibrary(bool bEnable) override { m_bLevelLib = bEnable; };
 
     //////////////////////////////////////////////////////////////////////////
     //! Return manager for this library.
-    IBaseLibraryManager* GetManager();
+    IBaseLibraryManager* GetManager() override;
 
     // Saves the library with the main tag defined by the parameter name
     bool SaveLibrary(const char* name, bool saveEmptyLibrary = false);
 
     //CONFETTI BEGIN
     // Used to change the library item order
-    virtual void ChangeItemOrder(CBaseLibraryItem* item, unsigned int newLocation) override;
+    void ChangeItemOrder(CBaseLibraryItem* item, unsigned int newLocation) override;
     //CONFETTI END
 
 signals:

Code/Editor/BaseLibraryManager.h

@@ -35,112 +35,112 @@ public:
     ~CBaseLibraryManager();
 
     //! Clear all libraries.
-    virtual void ClearAll() override;
+    void ClearAll() override;
 
     //////////////////////////////////////////////////////////////////////////
     // IDocListener implementation.
     //////////////////////////////////////////////////////////////////////////
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     //////////////////////////////////////////////////////////////////////////
     // Library items.
     //////////////////////////////////////////////////////////////////////////
     //! Make a new item in specified library.
-    virtual IDataBaseItem* CreateItem(IDataBaseLibrary* pLibrary) override;
+    IDataBaseItem* CreateItem(IDataBaseLibrary* pLibrary) override;
     //! Delete item from library and manager.
-    virtual void DeleteItem(IDataBaseItem* pItem) override;
+    void DeleteItem(IDataBaseItem* pItem) override;
 
     //! Find Item by its GUID.
-    virtual IDataBaseItem* FindItem(REFGUID guid) const;
-    virtual IDataBaseItem* FindItemByName(const QString& fullItemName);
-    virtual IDataBaseItem* LoadItemByName(const QString& fullItemName);
+    IDataBaseItem* FindItem(REFGUID guid) const override;
+    IDataBaseItem* FindItemByName(const QString& fullItemName) override;
+    IDataBaseItem* LoadItemByName(const QString& fullItemName) override;
     virtual IDataBaseItem* FindItemByName(const char* fullItemName);
     virtual IDataBaseItem* LoadItemByName(const char* fullItemName);
 
-    virtual IDataBaseItemEnumerator* GetItemEnumerator() override;
+    IDataBaseItemEnumerator* GetItemEnumerator() override;
 
     //////////////////////////////////////////////////////////////////////////
     // Set item currently selected.
-    virtual void SetSelectedItem(IDataBaseItem* pItem) override;
+    void SetSelectedItem(IDataBaseItem* pItem) override;
     // Get currently selected item.
-    virtual IDataBaseItem* GetSelectedItem() const override;
-    virtual IDataBaseItem* GetSelectedParentItem() const override;
+    IDataBaseItem* GetSelectedItem() const override;
+    IDataBaseItem* GetSelectedParentItem() const override;
 
     //////////////////////////////////////////////////////////////////////////
     // Libraries.
     //////////////////////////////////////////////////////////////////////////
     //! Add Item library.
-    virtual IDataBaseLibrary* AddLibrary(const QString& library, bool bIsLevelLibrary = false, bool bIsLoading = true) override;
-    virtual void DeleteLibrary(const QString& library, bool forceDeleteLevel = false) override;
+    IDataBaseLibrary* AddLibrary(const QString& library, bool bIsLevelLibrary = false, bool bIsLoading = true) override;
+    void DeleteLibrary(const QString& library, bool forceDeleteLevel = false) override;
     //! Get number of libraries.
-    virtual int GetLibraryCount() const override { return static_cast<int>(m_libs.size()); };
+    int GetLibraryCount() const override { return static_cast<int>(m_libs.size()); };
     //! Get number of modified libraries.
-    virtual int GetModifiedLibraryCount() const override;
+    int GetModifiedLibraryCount() const override;
 
     //! Get Item library by index.
-    virtual IDataBaseLibrary* GetLibrary(int index) const override;
+    IDataBaseLibrary* GetLibrary(int index) const override;
 
     //! Get Level Item library.
-    virtual IDataBaseLibrary* GetLevelLibrary() const override;
+    IDataBaseLibrary* GetLevelLibrary() const override;
 
     //! Find Items Library by name.
-    virtual IDataBaseLibrary* FindLibrary(const QString& library) override;
+    IDataBaseLibrary* FindLibrary(const QString& library) override;
 
     //! Find Items Library's index by name.
     int FindLibraryIndex(const QString& library) override;
     
     //! Load Items library.
-    virtual IDataBaseLibrary* LoadLibrary(const QString& filename, bool bReload = false) override;
+    IDataBaseLibrary* LoadLibrary(const QString& filename, bool bReload = false) override;
 
     //! Save all modified libraries.
-    virtual void SaveAllLibs() override;
+    void SaveAllLibs() override;
 
     //! Serialize property manager.
-    virtual void Serialize(XmlNodeRef& node, bool bLoading) override;
+    void Serialize(XmlNodeRef& node, bool bLoading) override;
 
     //! Export items to game.
-    virtual void Export([[maybe_unused]] XmlNodeRef& node) override {};
+    void Export([[maybe_unused]] XmlNodeRef& node) override {};
 
     //! Returns unique name base on input name.
-    virtual QString MakeUniqueItemName(const QString& name, const QString& libName = "") override;
-    virtual QString MakeFullItemName(IDataBaseLibrary* pLibrary, const QString& group, const QString& itemName) override;
+    QString MakeUniqueItemName(const QString& name, const QString& libName = "") override;
+    QString MakeFullItemName(IDataBaseLibrary* pLibrary, const QString& group, const QString& itemName) override;
 
     //! Root node where this library will be saved.
-    virtual QString GetRootNodeName() override = 0;
+    QString GetRootNodeName() override = 0;
     //! Path to libraries in this manager.
-    virtual QString GetLibsPath() override = 0;
+    QString GetLibsPath() override = 0;
 
     //////////////////////////////////////////////////////////////////////////
     //! Validate library items for errors.
-    virtual void Validate() override;
+    void Validate() override;
 
     //////////////////////////////////////////////////////////////////////////
-    virtual void GatherUsedResources(CUsedResources& resources) override;
+    void GatherUsedResources(CUsedResources& resources) override;
 
-    virtual void AddListener(IDataBaseManagerListener* pListener) override;
-    virtual void RemoveListener(IDataBaseManagerListener* pListener) override;
+    void AddListener(IDataBaseManagerListener* pListener) override;
+    void RemoveListener(IDataBaseManagerListener* pListener) override;
 
     //////////////////////////////////////////////////////////////////////////
-    virtual void RegisterItem(CBaseLibraryItem* pItem, REFGUID newGuid) override;
-    virtual void RegisterItem(CBaseLibraryItem* pItem) override;
-    virtual void UnregisterItem(CBaseLibraryItem* pItem) override;
+    void RegisterItem(CBaseLibraryItem* pItem, REFGUID newGuid) override;
+    void RegisterItem(CBaseLibraryItem* pItem) override;
+    void UnregisterItem(CBaseLibraryItem* pItem) override;
 
     // Only Used internally.
-    virtual void OnRenameItem(CBaseLibraryItem* pItem, const QString& oldName) override;
+    void OnRenameItem(CBaseLibraryItem* pItem, const QString& oldName) override;
 
     // Called by items to indicated that they have been modified.
     // Sends item changed event to listeners.
-    virtual void OnItemChanged(IDataBaseItem* pItem) override;
-    virtual void OnUpdateProperties(IDataBaseItem* pItem, bool bRefresh) override;
+    void OnItemChanged(IDataBaseItem* pItem) override;
+    void OnUpdateProperties(IDataBaseItem* pItem, bool bRefresh) override;
 
     QString MakeFilename(const QString& library);
-    virtual bool IsUniqueFilename(const QString& library) override;
+    bool IsUniqueFilename(const QString& library) override;
 
     //CONFETTI BEGIN
     // Used to change the library item order
-    virtual void ChangeLibraryOrder(IDataBaseLibrary* lib, unsigned int newLocation) override;
+    void ChangeLibraryOrder(IDataBaseLibrary* lib, unsigned int newLocation) override;
 
-    virtual bool SetLibraryName(CBaseLibrary* lib, const QString& name) override;
+    bool SetLibraryName(CBaseLibrary* lib, const QString& name) override;
 
 protected:
     void SplitFullItemName(const QString& fullItemName, QString& libraryName, QString& itemName);
@@ -199,8 +199,8 @@ public:
         m_pMap = pMap;
         m_iterator = m_pMap->begin();
     }
-    virtual void Release() { delete this; };
-    virtual IDataBaseItem* GetFirst()
+    void Release() override { delete this; };
+    IDataBaseItem* GetFirst() override
     {
         m_iterator = m_pMap->begin();
         if (m_iterator == m_pMap->end())
@@ -209,7 +209,7 @@ public:
         }
         return m_iterator->second;
     }
-    virtual IDataBaseItem* GetNext()
+    IDataBaseItem* GetNext() override
     {
         if (m_iterator != m_pMap->end())
         {

Code/Editor/Controls/ColorGradientCtrl.h

@@ -81,7 +81,7 @@ protected:
         HIT_SPLINE,
     };
 
-    void paintEvent(QPaintEvent* e);
+    void paintEvent(QPaintEvent* e) override;
     void resizeEvent(QResizeEvent* event) override;
     void mousePressEvent(QMouseEvent* event) override;
     void mouseReleaseEvent(QMouseEvent* event) override;

Code/Editor/Controls/FolderTreeCtrl.h

@@ -83,7 +83,7 @@ protected Q_SLOTS:
     void OnIndexDoubleClicked(const QModelIndex& index);
 
 protected:
-    virtual void OnFileMonitorChange(const SFileChangeInfo& rChange);
+    void OnFileMonitorChange(const SFileChangeInfo& rChange) override;
     void contextMenuEvent(QContextMenuEvent* e) override;
 
     void InitTree();

Code/Editor/Controls/ReflectedPropertyControl/ReflectedVarWrapper.h

@@ -123,7 +123,7 @@ public:
     void SetVariable(IVariable* pVariable) override;
     void SyncReflectedVarToIVar(IVariable* pVariable) override;
     void SyncIVarToReflectedVar(IVariable* pVariable) override;
-    virtual void OnVariableChange(IVariable* var);
+    void OnVariableChange(IVariable* var) override;
     CReflectedVar* GetReflectedVar() override { return m_reflectedVar.data(); }
 
 protected:

Code/Editor/Controls/SplineCtrlEx.h

@@ -159,15 +159,15 @@ public:
     //////////////////////////////////////////////////////////////////////////
 
     // IKeyTimeSet Implementation
-    virtual int GetKeyTimeCount() const;
-    virtual float GetKeyTime(int index) const;
-    virtual void MoveKeyTimes(int numChanges, int* indices, float scale, float offset, bool copyKeys);
-    virtual bool GetKeyTimeSelected(int index) const;
-    virtual void SetKeyTimeSelected(int index, bool selected);
-    virtual int GetKeyCount(int index) const;
-    virtual int GetKeyCountBound() const;
-    virtual void BeginEdittingKeyTimes();
-    virtual void EndEdittingKeyTimes();
+    int GetKeyTimeCount() const override;
+    float GetKeyTime(int index) const override;
+    void MoveKeyTimes(int numChanges, int* indices, float scale, float offset, bool copyKeys) override;
+    bool GetKeyTimeSelected(int index) const override;
+    void SetKeyTimeSelected(int index, bool selected) override;
+    int GetKeyCount(int index) const override;
+    int GetKeyCountBound() const override;
+    void BeginEdittingKeyTimes() override;
+    void EndEdittingKeyTimes() override;
 
     void SetEditLock(bool bLock) { m_bEditLock = bLock; }
 
@@ -361,8 +361,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); }
 

Code/Editor/Controls/TimelineCtrl.h

@@ -56,7 +56,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);
@@ -113,7 +113,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);

Code/Editor/EditorToolsApplication.h

@@ -28,7 +28,7 @@ namespace EditorInternal
 
         void RegisterCoreComponents() override;
 
-        AZ::ComponentTypeList GetRequiredSystemComponents() const;
+        AZ::ComponentTypeList GetRequiredSystemComponents() const override;
 
         void StartCommon(AZ::Entity* systemEntity) override;
 

Code/Editor/Export/ExportManager.h

@@ -36,8 +36,8 @@ namespace Export
     public:
         CMesh();
 
-        virtual int GetFaceCount() const { return static_cast<int>(m_faces.size()); }
-        virtual const Face* GetFaceBuffer() const { return m_faces.size() ? &m_faces[0] : 0; }
+        int GetFaceCount() const override { return static_cast<int>(m_faces.size()); }
+        const Face* GetFaceBuffer() const override { return !m_faces.empty() ? &m_faces[0] : nullptr; }
 
     private:
         std::vector<Face> m_faces;
@@ -54,13 +54,13 @@ namespace Export
         CObject(const char* pName);
 
         int GetVertexCount() const override { return static_cast<int>(m_vertices.size()); }
-        const Vector3D* GetVertexBuffer() const override { return m_vertices.size() ? &m_vertices[0] : nullptr; }
+        const Vector3D* GetVertexBuffer() const override { return !m_vertices.empty() ? &m_vertices[0] : nullptr; }
 
         int GetNormalCount() const override { return static_cast<int>(m_normals.size()); }
-        const Vector3D* GetNormalBuffer() const override { return m_normals.size() ? &m_normals[0] : nullptr; }
+        const Vector3D* GetNormalBuffer() const override { return !m_normals.empty() ? &m_normals[0] : nullptr; }
 
         int GetTexCoordCount() const override { return static_cast<int>(m_texCoords.size()); }
-        const UV* GetTexCoordBuffer() const override { return m_texCoords.size() ? &m_texCoords[0] : nullptr; }
+        const UV* GetTexCoordBuffer() const override { return !m_texCoords.empty() ? &m_texCoords[0] : nullptr; }
 
         int GetMeshCount() const override { return static_cast<int>(m_meshes.size()); }
         Mesh* GetMesh(int index) const override { return m_meshes[index]; }
@@ -68,9 +68,9 @@ namespace Export
         size_t  MeshHash() const override{return m_MeshHash; }
 
         void SetMaterialName(const char* pName);
-        virtual int GetEntityAnimationDataCount() const {return static_cast<int>(m_entityAnimData.size()); }
-        virtual const EntityAnimData* GetEntityAnimationData(int index) const {return &m_entityAnimData[index]; }
-        virtual void SetEntityAnimationData(EntityAnimData entityData){ m_entityAnimData.push_back(entityData); };
+        int GetEntityAnimationDataCount() const override {return static_cast<int>(m_entityAnimData.size()); }
+        const EntityAnimData* GetEntityAnimationData(int index) const override {return &m_entityAnimData[index]; }
+        void SetEntityAnimationData(EntityAnimData entityData) override{ m_entityAnimData.push_back(entityData); };
         void SetLastPtr(CBaseObject* pObject){m_pLastObject = pObject; };
         CBaseObject* GetLastObjectPtr(){return m_pLastObject; };
 
@@ -94,9 +94,9 @@ namespace Export
     public:
         virtual ~CData() = default;
 
-        virtual int GetObjectCount() const { return static_cast<int>(m_objects.size()); }
-        virtual Object* GetObject(int index) const { return m_objects[index]; }
-        virtual Object* AddObject(const char* objectName);
+        int GetObjectCount() const override { return static_cast<int>(m_objects.size()); }
+        Object* GetObject(int index) const override { return m_objects[index]; }
+        Object* AddObject(const char* objectName) override;
         void Clear();
 
     private:
@@ -119,7 +119,7 @@ public:
 
     //! Register exporter
     //! return true if succeed, otherwise false
-    virtual bool RegisterExporter(IExporter* pExporter);
+    bool RegisterExporter(IExporter* pExporter) override;
 
     //! Export specified geometry
     //! return true if succeed, otherwise false
@@ -141,15 +141,15 @@ public:
 
     //! Exports the stat obj to the obj file specified
     //! returns true if succeeded, otherwise false
-    virtual bool ExportSingleStatObj(IStatObj* pStatObj, const char* filename);
+    bool ExportSingleStatObj(IStatObj* pStatObj, const char* filename) override;
 
     void SetBakedKeysSequenceExport(bool bBaked){m_bBakedKeysSequenceExport = bBaked; };
 
     void SaveNodeKeysTimeToXML();
 
 private:
-    void AddMesh(Export::CObject* pObj, const IIndexedMesh* pIndMesh, Matrix34A* pTm = 0);
-    bool AddStatObj(Export::CObject* pObj, IStatObj* pStatObj, Matrix34A* pTm = 0);
+    void AddMesh(Export::CObject* pObj, const IIndexedMesh* pIndMesh, Matrix34A* pTm = nullptr);
+    bool AddStatObj(Export::CObject* pObj, IStatObj* pStatObj, Matrix34A* pTm = nullptr);
     bool AddMeshes(Export::CObject* pObj);
     bool AddObject(CBaseObject* pBaseObj);
     void SolveHierarchy();

Code/Editor/IEditorImpl.h

@@ -79,70 +79,70 @@ public:
 
 
     void SetGameEngine(CGameEngine* ge);
-    void DeleteThis() { delete this; };
-    IEditorClassFactory* GetClassFactory();
-    CEditorCommandManager* GetCommandManager() { return m_pCommandManager; };
-    ICommandManager* GetICommandManager() { return m_pCommandManager; }
-    void ExecuteCommand(const char* sCommand, ...);
-    void ExecuteCommand(const QString& command);
-    void SetDocument(CCryEditDoc* pDoc);
-    CCryEditDoc* GetDocument() const;
+    void DeleteThis() override { delete this; };
+    IEditorClassFactory* GetClassFactory() override;
+    CEditorCommandManager* GetCommandManager() override { return m_pCommandManager; };
+    ICommandManager* GetICommandManager() override { return m_pCommandManager; }
+    void ExecuteCommand(const char* sCommand, ...) override;
+    void ExecuteCommand(const QString& command) override;
+    void SetDocument(CCryEditDoc* pDoc) override;
+    CCryEditDoc* GetDocument() const override;
     bool IsLevelLoaded() const override;
-    void SetModifiedFlag(bool modified = true);
-    void SetModifiedModule(EModifiedModule  eModifiedModule, bool boSet = true);
-    bool IsLevelExported() const;
-    bool SetLevelExported(bool boExported = true);
+    void SetModifiedFlag(bool modified = true) override;
+    void SetModifiedModule(EModifiedModule  eModifiedModule, bool boSet = true) override;
+    bool IsLevelExported() const override;
+    bool SetLevelExported(bool boExported = true) override;
     void InitFinished();
-    bool IsModified();
-    bool IsInitialized() const{ return m_bInitialized; }
-    bool SaveDocument();
-    ISystem*    GetSystem();
-    void WriteToConsole(const char* string) { CLogFile::WriteLine(string); };
-    void WriteToConsole(const QString& string) { CLogFile::WriteLine(string); };
+    bool IsModified() override;
+    bool IsInitialized() const override{ return m_bInitialized; }
+    bool SaveDocument() override;
+    ISystem*    GetSystem() override;
+    void WriteToConsole(const char* string) override { CLogFile::WriteLine(string); };
+    void WriteToConsole(const QString& string) override { CLogFile::WriteLine(string); };
     // Change the message in the status bar
-    void SetStatusText(const QString& pszString);
-    virtual IMainStatusBar* GetMainStatusBar() override;
-    bool ShowConsole([[maybe_unused]] bool show)
+    void SetStatusText(const QString& pszString) override;
+    IMainStatusBar* GetMainStatusBar() override;
+    bool ShowConsole([[maybe_unused]] bool show) override
     {
         //if (AfxGetMainWnd())return ((CMainFrame *) (AfxGetMainWnd()))->ShowConsole(show);
         return false;
     }
 
-    void SetConsoleVar(const char* var, float value);
-    float GetConsoleVar(const char* var);
+    void SetConsoleVar(const char* var, float value) override;
+    float GetConsoleVar(const char* var) override;
     //! Query main window of the editor
     QMainWindow* GetEditorMainWindow() const override
     {
         return MainWindow::instance();
     };
 
-    QString GetPrimaryCDFolder();
+    QString GetPrimaryCDFolder() override;
     QString GetLevelName() override;
-    QString GetLevelFolder();
-    QString GetLevelDataFolder();
-    QString GetSearchPath(EEditorPathName path);
-    QString GetResolvedUserFolder();
-    bool ExecuteConsoleApp(const QString& CommandLine, QString& OutputText, bool bNoTimeOut = false, bool bShowWindow = false);
-    virtual bool IsInGameMode() override;
-    virtual void SetInGameMode(bool inGame) override;
-    virtual bool IsInSimulationMode() override;
-    virtual bool IsInTestMode() override;
-    virtual bool IsInPreviewMode() override;
-    virtual bool IsInConsolewMode() override;
-    virtual bool IsInLevelLoadTestMode() override;
-    virtual bool IsInMatEditMode() override { return m_bMatEditMode; }
+    QString GetLevelFolder() override;
+    QString GetLevelDataFolder() override;
+    QString GetSearchPath(EEditorPathName path) override;
+    QString GetResolvedUserFolder() override;
+    bool ExecuteConsoleApp(const QString& CommandLine, QString& OutputText, bool bNoTimeOut = false, bool bShowWindow = false) override;
+    bool IsInGameMode() override;
+    void SetInGameMode(bool inGame) override;
+    bool IsInSimulationMode() override;
+    bool IsInTestMode() override;
+    bool IsInPreviewMode() override;
+    bool IsInConsolewMode() override;
+    bool IsInLevelLoadTestMode() override;
+    bool IsInMatEditMode() override { return m_bMatEditMode; }
 
     //! Enables/Disable updates of editor.
-    void EnableUpdate(bool enable) { m_bUpdates = enable; };
+    void EnableUpdate(bool enable) override { m_bUpdates = enable; };
     //! Enable/Disable accelerator table, (Enabled by default).
-    void EnableAcceleratos(bool bEnable);
-    CGameEngine* GetGameEngine() { return m_pGameEngine; };
-    CDisplaySettings*   GetDisplaySettings() { return m_pDisplaySettings; };
-    const SGizmoParameters& GetGlobalGizmoParameters();
-    CBaseObject* NewObject(const char* typeName, const char* fileName = "", const char* name = "", float x = 0.0f, float y = 0.0f, float z = 0.0f, bool modifyDoc = true);
-    void DeleteObject(CBaseObject* obj);
-    CBaseObject* CloneObject(CBaseObject* obj);
-    IObjectManager* GetObjectManager();
+    void EnableAcceleratos(bool bEnable) override;
+    CGameEngine* GetGameEngine() override { return m_pGameEngine; };
+    CDisplaySettings*   GetDisplaySettings() override { return m_pDisplaySettings; };
+    const SGizmoParameters& GetGlobalGizmoParameters() override;
+    CBaseObject* NewObject(const char* typeName, const char* fileName = "", const char* name = "", float x = 0.0f, float y = 0.0f, float z = 0.0f, bool modifyDoc = true) override;
+    void DeleteObject(CBaseObject* obj) override;
+    CBaseObject* CloneObject(CBaseObject* obj) override;
+    IObjectManager* GetObjectManager() override;
     // This will return a null pointer if CrySystem is not loaded before
     // Global Sandbox Settings are loaded from the registry before CrySystem
     // At that stage GetSettingsManager will return null and xml node in
@@ -150,27 +150,27 @@ public:
     // After m_IEditor is created and CrySystem loaded, it is possible
     // to feed memory node with all necessary data needed for export
     // (gSettings.Load() and CXTPDockingPaneManager/CXTPDockingPaneLayout Sandbox layout management)
-    CSettingsManager* GetSettingsManager();
-    CSelectionGroup*    GetSelection();
-    int ClearSelection();
-    CBaseObject* GetSelectedObject();
-    void SelectObject(CBaseObject* obj);
-    void LockSelection(bool bLock);
-    bool IsSelectionLocked();
+    CSettingsManager* GetSettingsManager() override;
+    CSelectionGroup*    GetSelection() override;
+    int ClearSelection() override;
+    CBaseObject* GetSelectedObject() override;
+    void SelectObject(CBaseObject* obj) override;
+    void LockSelection(bool bLock) override;
+    bool IsSelectionLocked() override;
 
-    IDataBaseManager* GetDBItemManager(EDataBaseItemType itemType);
-    CMusicManager* GetMusicManager() { return m_pMusicManager; };
+    IDataBaseManager* GetDBItemManager(EDataBaseItemType itemType) override;
+    CMusicManager* GetMusicManager() override { return m_pMusicManager; };
 
     IEditorFileMonitor* GetFileMonitor() override;
     void RegisterEventLoopHook(IEventLoopHook* pHook) override;
     void UnregisterEventLoopHook(IEventLoopHook* pHook) override;
-    IIconManager* GetIconManager();
-    float GetTerrainElevation(float x, float y);
-    Editor::EditorQtApplication* GetEditorQtApplication() { return m_QtApplication; }
+    IIconManager* GetIconManager() override;
+    float GetTerrainElevation(float x, float y) override;
+    Editor::EditorQtApplication* GetEditorQtApplication() override { return m_QtApplication; }
     const QColor& GetColorByName(const QString& name) override;
 
     //////////////////////////////////////////////////////////////////////////
-    IMovieSystem* GetMovieSystem()
+    IMovieSystem* GetMovieSystem() override
     {
         if (m_pSystem)
         {
@@ -179,37 +179,37 @@ public:
         return nullptr;
     };
 
-    CPluginManager* GetPluginManager() { return m_pPluginManager; }
-    CViewManager* GetViewManager();
-    CViewport* GetActiveView();
-    void SetActiveView(CViewport* viewport);
+    CPluginManager* GetPluginManager() override { return m_pPluginManager; }
+    CViewManager* GetViewManager() override;
+    CViewport* GetActiveView() override;
+    void SetActiveView(CViewport* viewport) override;
 
-    CLevelIndependentFileMan* GetLevelIndependentFileMan() { return m_pLevelIndependentFileMan; }
+    CLevelIndependentFileMan* GetLevelIndependentFileMan() override { return m_pLevelIndependentFileMan; }
 
-    void UpdateViews(int flags, const AABB* updateRegion);
-    void ResetViews();
-    void ReloadTrackView();
-    Vec3 GetMarkerPosition() { return m_marker; };
-    void SetMarkerPosition(const Vec3& pos) { m_marker = pos; };
-    void    SetSelectedRegion(const AABB& box);
-    void    GetSelectedRegion(AABB& box);
+    void UpdateViews(int flags, const AABB* updateRegion) override;
+    void ResetViews() override;
+    void ReloadTrackView() override;
+    Vec3 GetMarkerPosition() override { return m_marker; };
+    void SetMarkerPosition(const Vec3& pos) override { m_marker = pos; };
+    void    SetSelectedRegion(const AABB& box) override;
+    void    GetSelectedRegion(AABB& box) override;
     bool AddToolbarItem(uint8 iId, IUIEvent* pIHandler);
-    void SetDataModified();
-    void SetOperationMode(EOperationMode mode);
-    EOperationMode GetOperationMode();
+    void SetDataModified() override;
+    void SetOperationMode(EOperationMode mode) override;
+    EOperationMode GetOperationMode() override;
 
-    ITransformManipulator* ShowTransformManipulator(bool bShow);
-    ITransformManipulator* GetTransformManipulator();
-    void SetAxisConstraints(AxisConstrains axis);
-    AxisConstrains GetAxisConstrains();
-    void SetAxisVectorLock(bool bAxisVectorLock) { m_bAxisVectorLock = bAxisVectorLock; }
-    bool IsAxisVectorLocked() { return m_bAxisVectorLock; }
-    void SetTerrainAxisIgnoreObjects(bool bIgnore);
-    bool IsTerrainAxisIgnoreObjects();
-    void SetReferenceCoordSys(RefCoordSys refCoords);
-    RefCoordSys GetReferenceCoordSys();
-    XmlNodeRef FindTemplate(const QString& templateName);
-    void AddTemplate(const QString& templateName, XmlNodeRef& tmpl);
+    ITransformManipulator* ShowTransformManipulator(bool bShow) override;
+    ITransformManipulator* GetTransformManipulator() override;
+    void SetAxisConstraints(AxisConstrains axis) override;
+    AxisConstrains GetAxisConstrains() override;
+    void SetAxisVectorLock(bool bAxisVectorLock) override { m_bAxisVectorLock = bAxisVectorLock; }
+    bool IsAxisVectorLocked() override { return m_bAxisVectorLock; }
+    void SetTerrainAxisIgnoreObjects(bool bIgnore) override;
+    bool IsTerrainAxisIgnoreObjects() override;
+    void SetReferenceCoordSys(RefCoordSys refCoords) override;
+    RefCoordSys GetReferenceCoordSys() override;
+    XmlNodeRef FindTemplate(const QString& templateName) override;
+    void AddTemplate(const QString& templateName, XmlNodeRef& tmpl) override;
 
     const QtViewPane* OpenView(QString sViewClassName, bool reuseOpened = true) override;
 
@@ -220,87 +220,87 @@ public:
      */
     QWidget* FindView(QString viewClassName) override;
 
-    bool CloseView(const char* sViewClassName);
-    bool SetViewFocus(const char* sViewClassName);
+    bool CloseView(const char* sViewClassName) override;
+    bool SetViewFocus(const char* sViewClassName) override;
 
-    virtual QWidget* OpenWinWidget(WinWidgetId openId) override;
-    virtual WinWidget::WinWidgetManager* GetWinWidgetManager() const override;
+    QWidget* OpenWinWidget(WinWidgetId openId) override;
+    WinWidget::WinWidgetManager* GetWinWidgetManager() const override;
 
     // close ALL panels related to classId, used when unloading plugins.
-    void CloseView(const GUID& classId);
+    void CloseView(const GUID& classId) override;
     bool SelectColor(QColor &color, QWidget *parent = 0) override;
     void Update();
-    SFileVersion GetFileVersion() { return m_fileVersion; };
-    SFileVersion GetProductVersion() { return m_productVersion; };
+    SFileVersion GetFileVersion() override { return m_fileVersion; };
+    SFileVersion GetProductVersion() override { return m_productVersion; };
     //! Get shader enumerator.
-    CUndoManager* GetUndoManager() { return m_pUndoManager; };
-    void BeginUndo();
-    void RestoreUndo(bool undo);
-    void AcceptUndo(const QString& name);
-    void CancelUndo();
-    void SuperBeginUndo();
-    void SuperAcceptUndo(const QString& name);
-    void SuperCancelUndo();
-    void SuspendUndo();
-    void ResumeUndo();
-    void Undo();
-    void Redo();
-    bool IsUndoRecording();
-    bool IsUndoSuspended();
-    void RecordUndo(IUndoObject* obj);
-    bool FlushUndo(bool isShowMessage = false);
-    bool ClearLastUndoSteps(int steps);
-    bool ClearRedoStack();
+    CUndoManager* GetUndoManager() override { return m_pUndoManager; };
+    void BeginUndo() override;
+    void RestoreUndo(bool undo) override;
+    void AcceptUndo(const QString& name) override;
+    void CancelUndo() override;
+    void SuperBeginUndo() override;
+    void SuperAcceptUndo(const QString& name) override;
+    void SuperCancelUndo() override;
+    void SuspendUndo() override;
+    void ResumeUndo() override;
+    void Undo() override;
+    void Redo() override;
+    bool IsUndoRecording() override;
+    bool IsUndoSuspended() override;
+    void RecordUndo(IUndoObject* obj) override;
+    bool FlushUndo(bool isShowMessage = false) override;
+    bool ClearLastUndoSteps(int steps) override;
+    bool ClearRedoStack() override;
     //! Retrieve current animation context.
-    CAnimationContext* GetAnimation();
+    CAnimationContext* GetAnimation() override;
     CTrackViewSequenceManager* GetSequenceManager() override;
     ITrackViewSequenceManager* GetSequenceManagerInterface() override;
 
-    CToolBoxManager* GetToolBoxManager() { return m_pToolBoxManager; };
-    IErrorReport* GetErrorReport() { return m_pErrorReport; }
-    IErrorReport* GetLastLoadedLevelErrorReport() { return m_pLasLoadedLevelErrorReport; }
+    CToolBoxManager* GetToolBoxManager() override { return m_pToolBoxManager; };
+    IErrorReport* GetErrorReport() override { return m_pErrorReport; }
+    IErrorReport* GetLastLoadedLevelErrorReport() override { return m_pLasLoadedLevelErrorReport; }
     void StartLevelErrorReportRecording() override;
-    void CommitLevelErrorReport() {SAFE_DELETE(m_pLasLoadedLevelErrorReport); m_pLasLoadedLevelErrorReport = new CErrorReport(*m_pErrorReport); }
-    virtual IFileUtil* GetFileUtil() override { return m_pFileUtil;  }
-    void Notify(EEditorNotifyEvent event);
-    void NotifyExcept(EEditorNotifyEvent event, IEditorNotifyListener* listener);
-    void RegisterNotifyListener(IEditorNotifyListener* listener);
-    void UnregisterNotifyListener(IEditorNotifyListener* listener);
+    void CommitLevelErrorReport() override {SAFE_DELETE(m_pLasLoadedLevelErrorReport); m_pLasLoadedLevelErrorReport = new CErrorReport(*m_pErrorReport); }
+    IFileUtil* GetFileUtil() override { return m_pFileUtil;  }
+    void Notify(EEditorNotifyEvent event) override;
+    void NotifyExcept(EEditorNotifyEvent event, IEditorNotifyListener* listener) override;
+    void RegisterNotifyListener(IEditorNotifyListener* listener) override;
+    void UnregisterNotifyListener(IEditorNotifyListener* listener) override;
     //! Register document notifications listener.
-    void RegisterDocListener(IDocListener* listener);
+    void RegisterDocListener(IDocListener* listener) override;
     //! Unregister document notifications listener.
-    void UnregisterDocListener(IDocListener* listener);
+    void UnregisterDocListener(IDocListener* listener) override;
     //! Retrieve interface to the source control.
-    ISourceControl* GetSourceControl();
+    ISourceControl* GetSourceControl() override;
     //! Retrieve true if source control is provided and enabled in settings
     bool IsSourceControlAvailable() override;
     //! Only returns true if source control is both available AND currently connected and functioning
     bool IsSourceControlConnected() override;
     //! Setup Material Editor mode
     void SetMatEditMode(bool bIsMatEditMode);
-    CUIEnumsDatabase* GetUIEnumsDatabase() { return m_pUIEnumsDatabase; };
-    void AddUIEnums();
-    void ReduceMemory();
+    CUIEnumsDatabase* GetUIEnumsDatabase() override { return m_pUIEnumsDatabase; };
+    void AddUIEnums() override;
+    void ReduceMemory() override;
     // Get Export manager
-    IExportManager* GetExportManager();
+    IExportManager* GetExportManager() override;
     // Set current configuration spec of the editor.
-    void SetEditorConfigSpec(ESystemConfigSpec spec, ESystemConfigPlatform platform);
-    ESystemConfigSpec GetEditorConfigSpec() const;
-    ESystemConfigPlatform GetEditorConfigPlatform() const;
-    void ReloadTemplates();
+    void SetEditorConfigSpec(ESystemConfigSpec spec, ESystemConfigPlatform platform) override;
+    ESystemConfigSpec GetEditorConfigSpec() const override;
+    ESystemConfigPlatform GetEditorConfigPlatform() const override;
+    void ReloadTemplates() override;
     void AddErrorMessage(const QString& text, const QString& caption);
-    virtual void ShowStatusText(bool bEnable);
+    void ShowStatusText(bool bEnable) override;
 
     void OnObjectContextMenuOpened(QMenu* pMenu, const CBaseObject* pObject);
-    virtual void RegisterObjectContextMenuExtension(TContextMenuExtensionFunc func) override;
+    void RegisterObjectContextMenuExtension(TContextMenuExtensionFunc func) override;
 
-    virtual SSystemGlobalEnvironment* GetEnv() override;
-    virtual IBaseLibraryManager* GetMaterialManagerLibrary() override; // Vladimir@Conffx
-    virtual IEditorMaterialManager* GetIEditorMaterialManager() override; // Vladimir@Conffx
-    virtual IImageUtil* GetImageUtil() override;  // Vladimir@conffx
-    virtual SEditorSettings* GetEditorSettings() override;
-    virtual IEditorPanelUtils* GetEditorPanelUtils() override;
-    virtual ILogFile* GetLogFile() override { return m_pLogFile; }
+    SSystemGlobalEnvironment* GetEnv() override;
+    IBaseLibraryManager* GetMaterialManagerLibrary() override; // Vladimir@Conffx
+    IEditorMaterialManager* GetIEditorMaterialManager() override; // Vladimir@Conffx
+    IImageUtil* GetImageUtil() override;  // Vladimir@conffx
+    SEditorSettings* GetEditorSettings() override;
+    IEditorPanelUtils* GetEditorPanelUtils() override;
+    ILogFile* GetLogFile() override { return m_pLogFile; }
 
     void UnloadPlugins() override;
     void LoadPlugins() override;

Code/Editor/LevelTreeModel.h

@@ -23,7 +23,7 @@ class LevelTreeModelFilter
     Q_OBJECT
 public:
     explicit LevelTreeModelFilter(QObject* parent = nullptr);
-    bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const;
+    bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override;
     void setFilterText(const QString&);
     QVariant data(const QModelIndex& index, int role) const override;
 private:

Code/Editor/Objects/AxisGizmo.h

@@ -35,21 +35,21 @@ public:
     //////////////////////////////////////////////////////////////////////////
     // Ovverides from CGizmo
     //////////////////////////////////////////////////////////////////////////
-    virtual void GetWorldBounds(AABB& bbox);
-    virtual void Display(DisplayContext& dc);
-    virtual bool HitTest(HitContext& hc);
-    virtual const Matrix34& GetMatrix() const;
+    void GetWorldBounds(AABB& bbox) override;
+    void Display(DisplayContext& dc) override;
+    bool HitTest(HitContext& hc) override;
+    const Matrix34& GetMatrix() const override;
     //////////////////////////////////////////////////////////////////////////
 
 
     //////////////////////////////////////////////////////////////////////////
     // ITransformManipulator implementation.
     //////////////////////////////////////////////////////////////////////////
-    virtual Matrix34 GetTransformation(RefCoordSys coordSys, IDisplayViewport* view = nullptr) const;
-    virtual void SetTransformation(RefCoordSys coordSys, const Matrix34& tm);
-    virtual bool HitTestManipulator(HitContext& hc);
-    virtual bool MouseCallback(CViewport* view, EMouseEvent event, QPoint& point, int nFlags);
-    virtual void SetAlwaysUseLocal(bool on)
+    Matrix34 GetTransformation(RefCoordSys coordSys, IDisplayViewport* view = nullptr) const override;
+    void SetTransformation(RefCoordSys coordSys, const Matrix34& tm) override;
+    bool HitTestManipulator(HitContext& hc) override;
+    bool MouseCallback(CViewport* view, EMouseEvent event, QPoint& point, int nFlags) override;
+    void SetAlwaysUseLocal(bool on) override
     { m_bAlwaysUseLocal = on; }
     //////////////////////////////////////////////////////////////////////////
 

Code/Editor/Objects/BaseObject.h

@@ -712,7 +712,7 @@ protected:
     // May be overridden in derived classes to handle helpers scaling.
     //////////////////////////////////////////////////////////////////////////
     virtual void SetHelperScale([[maybe_unused]] float scale) {};
-    virtual float GetHelperScale() { return 1; };
+    virtual float GetHelperScale() { return 1.0f; };
 
     void SetNameInternal(const QString& name) { m_name = name; }
 

Code/Editor/Objects/EntityObject.h

@@ -82,14 +82,14 @@ public:
     // Overrides from CBaseObject.
     //////////////////////////////////////////////////////////////////////////
     //! Return type name of Entity.
-    QString GetTypeDescription() const { return GetEntityClass(); };
+    QString GetTypeDescription() const override { return GetEntityClass(); };
 
     //////////////////////////////////////////////////////////////////////////
-    bool IsSameClass(CBaseObject* obj);
+    bool IsSameClass(CBaseObject* obj) override;
 
-    virtual bool Init(IEditor* ie, CBaseObject* prev, const QString& file);
-    virtual void InitVariables();
-    virtual void Done();
+    bool Init(IEditor* ie, CBaseObject* prev, const QString& file) override;
+    void InitVariables() override;
+    void Done() override;
 
     void DrawExtraLightInfo (DisplayContext& disp);
 
@@ -102,30 +102,30 @@ public:
     void SetEntityPropertyFloat(const char* name, float value);
     void SetEntityPropertyString(const char* name, const QString& value);
 
-    virtual int MouseCreateCallback(CViewport* view, EMouseEvent event, QPoint& point, int flags);
-    virtual void OnContextMenu(QMenu* menu);
+    int MouseCreateCallback(CViewport* view, EMouseEvent event, QPoint& point, int flags) override;
+    void OnContextMenu(QMenu* menu) override;
 
-    void SetName(const QString& name);
-    void SetSelected(bool bSelect);
+    void SetName(const QString& name) override;
+    void SetSelected(bool bSelect) override;
 
-    virtual void GetLocalBounds(AABB& box);
+    void GetLocalBounds(AABB& box) override;
 
-    virtual bool HitTest(HitContext& hc);
-    virtual bool HitHelperTest(HitContext& hc);
-    virtual bool HitTestRect(HitContext& hc);
-    void UpdateVisibility(bool bVisible);
-    bool ConvertFromObject(CBaseObject* object);
+    bool HitTest(HitContext& hc) override;
+    bool HitHelperTest(HitContext& hc) override;
+    bool HitTestRect(HitContext& hc) override;
+    void UpdateVisibility(bool bVisible) override;
+    bool ConvertFromObject(CBaseObject* object) override;
 
     using CBaseObject::Serialize;
     void Serialize(CObjectArchive& ar) override;
-    virtual void PostLoad(CObjectArchive& ar);
+    void PostLoad(CObjectArchive& ar) override;
 
-    XmlNodeRef Export(const QString& levelPath, XmlNodeRef& xmlNode);
+    XmlNodeRef Export(const QString& levelPath, XmlNodeRef& xmlNode) override;
 
     //////////////////////////////////////////////////////////////////////////
-    void OnEvent(ObjectEvent event);
+    void OnEvent(ObjectEvent event) override;
 
-    virtual void SetTransformDelegate(ITransformDelegate* pTransformDelegate) override;
+    void SetTransformDelegate(ITransformDelegate* pTransformDelegate) override;
 
     // Set attach flags and target
     enum EAttachmentType
@@ -140,15 +140,15 @@ public:
     EAttachmentType GetAttachType() const { return m_attachmentType; }
     QString GetAttachTarget() const { return m_attachmentTarget; }
 
-    virtual void SetHelperScale(float scale);
-    virtual float GetHelperScale();
+    void SetHelperScale(float scale) override;
+    float GetHelperScale() override;
 
-    virtual void GatherUsedResources(CUsedResources& resources);
-    virtual bool IsSimilarObject(CBaseObject* pObject);
+    void GatherUsedResources(CUsedResources& resources) override;
+    bool IsSimilarObject(CBaseObject* pObject) override;
 
-    virtual bool HasMeasurementAxis() const {   return false;   }
+    bool HasMeasurementAxis() const override {   return false;   }
 
-    virtual bool IsIsolated() const { return false; }
+    bool IsIsolated() const override { return false; }
 
     //////////////////////////////////////////////////////////////////////////
     // END CBaseObject
@@ -233,7 +233,7 @@ protected:
     //////////////////////////////////////////////////////////////////////////
     //! Must be called after cloning the object on clone of object.
     //! This will make sure object references are cloned correctly.
-    virtual void PostClone(CBaseObject* pFromObject, CObjectCloneContext& ctx);
+    void PostClone(CBaseObject* pFromObject, CObjectCloneContext& ctx) override;
 
     //! Draw default object items.
     void DrawProjectorPyramid(DisplayContext& dc, float dist);
@@ -265,7 +265,7 @@ public:
     }
 
 protected:
-    void DeleteThis() { delete this; };
+    void DeleteThis() override { delete this; };
 
     //////////////////////////////////////////////////////////////////////////
     // Radius callbacks.

Code/Editor/Objects/GizmoManager.h

@@ -23,14 +23,14 @@ class CGizmoManager
     : public IGizmoManager
 {
 public:
-    void AddGizmo(CGizmo* gizmo);
-    void RemoveGizmo(CGizmo* gizmo);
+    void AddGizmo(CGizmo* gizmo) override;
+    void RemoveGizmo(CGizmo* gizmo) override;
 
     int GetGizmoCount() const override;
     CGizmo* GetGizmoByIndex(int nIndex) const override;
 
-    void Display(DisplayContext& dc);
-    bool HitTest(HitContext& hc);
+    void Display(DisplayContext& dc) override;
+    bool HitTest(HitContext& hc) override;
 
     void DeleteAllTransformManipulators();
 

Code/Editor/Objects/LineGizmo.h

@@ -30,10 +30,10 @@ public:
     //////////////////////////////////////////////////////////////////////////
     // Ovverides from CGizmo
     //////////////////////////////////////////////////////////////////////////
-    virtual void SetName(const char* sName);
-    virtual void GetWorldBounds(AABB& bbox);
-    virtual void Display(DisplayContext& dc);
-    virtual bool HitTest(HitContext& hc);
+    void SetName(const char* sName) override;
+    void GetWorldBounds(AABB& bbox) override;
+    void Display(DisplayContext& dc) override;
+    bool HitTest(HitContext& hc) override;
 
     //////////////////////////////////////////////////////////////////////////
     void SetObjects(CBaseObject* pObject1, CBaseObject* pObject2, const QString& boneName = "");

Code/Editor/Objects/ObjectManager.h

@@ -103,142 +103,142 @@ public:
 
     void RegisterObjectClasses();
 
-    CBaseObject* NewObject(CObjectClassDesc* cls, CBaseObject* prev = 0, const QString& file = "", const char* newObjectName = nullptr);
-    CBaseObject* NewObject(const QString& typeName, CBaseObject* prev = 0, const QString& file = "", const char* newEntityName = nullptr);
+    CBaseObject* NewObject(CObjectClassDesc* cls, CBaseObject* prev = 0, const QString& file = "", const char* newObjectName = nullptr) override;
+    CBaseObject* NewObject(const QString& typeName, CBaseObject* prev = 0, const QString& file = "", const char* newEntityName = nullptr) override;
 
-    void    DeleteObject(CBaseObject* obj);
-    void    DeleteSelection(CSelectionGroup* pSelection);
-    void    DeleteAllObjects();
-    CBaseObject* CloneObject(CBaseObject* obj);
+    void    DeleteObject(CBaseObject* obj) override;
+    void    DeleteSelection(CSelectionGroup* pSelection) override;
+    void    DeleteAllObjects() override;
+    CBaseObject* CloneObject(CBaseObject* obj) override;
 
-    void BeginEditParams(CBaseObject* obj, int flags);
-    void EndEditParams(int flags = 0);
+    void BeginEditParams(CBaseObject* obj, int flags) override;
+    void EndEditParams(int flags = 0) override;
     // Hides all transform manipulators.
     void HideTransformManipulators();
 
     //! Get number of objects manager by ObjectManager (not contain sub objects of groups).
-    int     GetObjectCount() const;
+    int     GetObjectCount() const override;
 
     //! Get array of objects, managed by manager (not contain sub objects of groups).
     //! @param layer if 0 get objects for all layers, or layer to get objects from.
-    void GetObjects(CBaseObjectsArray& objects) const;
+    void GetObjects(CBaseObjectsArray& objects) const override;
 
     //! Get array of objects that pass the filter.
     //! @param filter The filter functor, return true if you want to get the certain obj, return false if want to skip it.
-    void    GetObjects(CBaseObjectsArray& objects, BaseObjectFilterFunctor const& filter) const;
+    void    GetObjects(CBaseObjectsArray& objects, BaseObjectFilterFunctor const& filter) const override;
 
     //! Update objects.
     void    Update();
 
     //! Display objects on display context.
-    void    Display(DisplayContext& dc);
+    void    Display(DisplayContext& dc) override;
 
     //! Called when selecting without selection helpers - this is needed since
     //! the visible object cache is normally not updated when not displaying helpers.
-    void ForceUpdateVisibleObjectCache(DisplayContext& dc);
+    void ForceUpdateVisibleObjectCache(DisplayContext& dc) override;
 
     //! Check intersection with objects.
     //! Find intersection with nearest to ray origin object hit by ray.
     //! If distance tollerance is specified certain relaxation applied on collision test.
     //! @return true if hit any object, and fills hitInfo structure.
-    bool HitTest(HitContext& hitInfo);
+    bool HitTest(HitContext& hitInfo) override;
 
     //! Check intersection with an object.
     //! @return true if hit, and fills hitInfo structure.
-    bool HitTestObject(CBaseObject* obj, HitContext& hc);
+    bool HitTestObject(CBaseObject* obj, HitContext& hc) override;
 
     //! Send event to all objects.
     //! Will cause OnEvent handler to be called on all objects.
-    void    SendEvent(ObjectEvent event);
+    void    SendEvent(ObjectEvent event) override;
 
     //! Send event to all objects within given bounding box.
     //! Will cause OnEvent handler to be called on objects within bounding box.
-    void    SendEvent(ObjectEvent event, const AABB& bounds);
+    void    SendEvent(ObjectEvent event, const AABB& bounds) override;
 
     //////////////////////////////////////////////////////////////////////////
     //! Find object by ID.
-    CBaseObject* FindObject(REFGUID guid) const;
+    CBaseObject* FindObject(REFGUID guid) const override;
     //////////////////////////////////////////////////////////////////////////
     //! Find object by name.
-    CBaseObject* FindObject(const QString& sName) const;
+    CBaseObject* FindObject(const QString& sName) const override;
     //////////////////////////////////////////////////////////////////////////
     //! Find objects of given type.
     void FindObjectsOfType(const QMetaObject* pClass, std::vector<CBaseObject*>& result) override;
     void FindObjectsOfType(ObjectType type, std::vector<CBaseObject*>& result) override;
     //////////////////////////////////////////////////////////////////////////
     //! Find objects which intersect with a given AABB.
-    virtual void FindObjectsInAABB(const AABB& aabb, std::vector<CBaseObject*>& result) const;
+    void FindObjectsInAABB(const AABB& aabb, std::vector<CBaseObject*>& result) const override;
 
     //////////////////////////////////////////////////////////////////////////
     // Operations on objects.
     //////////////////////////////////////////////////////////////////////////
     //! Makes object visible or invisible.
-    void HideObject(CBaseObject* obj, bool hide);
+    void HideObject(CBaseObject* obj, bool hide) override;
     //! Shows the last hidden object based on hidden ID
-    void ShowLastHiddenObject();
+    void ShowLastHiddenObject() override;
     //! Freeze object, making it unselectable.
-    void FreezeObject(CBaseObject* obj, bool freeze);
+    void FreezeObject(CBaseObject* obj, bool freeze) override;
     //! Unhide all hidden objects.
-    void UnhideAll();
+    void UnhideAll() override;
     //! Unfreeze all frozen objects.
-    void UnfreezeAll();
+    void UnfreezeAll() override;
 
     //////////////////////////////////////////////////////////////////////////
     // Object Selection.
     //////////////////////////////////////////////////////////////////////////
-    bool    SelectObject(CBaseObject* obj, bool bUseMask = true);
-    void    UnselectObject(CBaseObject* obj);
+    bool    SelectObject(CBaseObject* obj, bool bUseMask = true) override;
+    void    UnselectObject(CBaseObject* obj) override;
 
     //! Select objects within specified distance from given position.
     //! Return number of selected objects.
-    int SelectObjects(const AABB& box, bool bUnselect = false);
+    int SelectObjects(const AABB& box, bool bUnselect = false) override;
 
-    virtual void SelectEntities(std::set<CEntityObject*>& s);
+    void SelectEntities(std::set<CEntityObject*>& s) override;
 
-    int MoveObjects(const AABB& box, const Vec3& offset, ImageRotationDegrees rotation, bool bIsCopy = false);
+    int MoveObjects(const AABB& box, const Vec3& offset, ImageRotationDegrees rotation, bool bIsCopy = false) override;
 
     //! Selects/Unselects all objects within 2d rectangle in given viewport.
-    void SelectObjectsInRect(CViewport* view, const QRect& rect, bool bSelect);
-    void FindObjectsInRect(CViewport* view, const QRect& rect, std::vector<GUID>& guids);
+    void SelectObjectsInRect(CViewport* view, const QRect& rect, bool bSelect) override;
+    void FindObjectsInRect(CViewport* view, const QRect& rect, std::vector<GUID>& guids) override;
 
     //! Clear default selection set.
     //! @Return number of objects removed from selection.
-    int ClearSelection();
+    int ClearSelection() override;
 
     //! Deselect all current selected objects and selects object that were unselected.
     //! @Return number of selected objects.
-    int InvertSelection();
+    int InvertSelection() override;
 
     //! Get current selection.
-    CSelectionGroup*    GetSelection() const { return m_currSelection; };
+    CSelectionGroup*    GetSelection() const override { return m_currSelection; };
     //! Get named selection.
-    CSelectionGroup*    GetSelection(const QString& name) const;
+    CSelectionGroup*    GetSelection(const QString& name) const override;
     // Get selection group names
-    void GetNameSelectionStrings(QStringList& names);
+    void GetNameSelectionStrings(QStringList& names) override;
     //! Change name of current selection group.
     //! And store it in list.
-    void    NameSelection(const QString& name);
+    void    NameSelection(const QString& name) override;
     //! Set one of name selections as current selection.
-    void    SetSelection(const QString& name);
-    void    RemoveSelection(const QString& name);
+    void    SetSelection(const QString& name) override;
+    void    RemoveSelection(const QString& name) override;
 
     bool IsObjectDeletionAllowed(CBaseObject* pObject);
 
     //! Delete all objects in selection group.
-    void DeleteSelection();
+    void DeleteSelection() override;
 
-    uint32  ForceID() const{return m_ForceID; }
-    void    ForceID(uint32 FID){m_ForceID = FID; }
+    uint32  ForceID() const override{return m_ForceID; }
+    void    ForceID(uint32 FID) override{m_ForceID = FID; }
 
     //! Generates uniq name base on type name of object.
-    QString GenerateUniqueObjectName(const QString& typeName);
+    QString GenerateUniqueObjectName(const QString& typeName) override;
     //! Register object name in object manager, needed for generating uniq names.
-    void RegisterObjectName(const QString& name);
+    void RegisterObjectName(const QString& name) override;
     //! Decrease name number and remove if it was last in object manager, needed for generating uniq names.
     void UpdateRegisterObjectName(const QString& name);
     //! Enable/Disable generating of unique object names (Enabled by default).
     //! Return previous value.
-    bool EnableUniqObjectNames(bool bEnable);
+    bool EnableUniqObjectNames(bool bEnable) override;
 
     //! Register XML template of runtime class.
     void    RegisterClassTemplate(const XmlNodeRef& templ);
@@ -249,25 +249,25 @@ public:
     void RegisterCVars();
 
     //! Find object class by name.
-    CObjectClassDesc* FindClass(const QString& className);
-    void    GetClassCategories(QStringList& categories);
+    CObjectClassDesc* FindClass(const QString& className) override;
+    void    GetClassCategories(QStringList& categories) override;
     void    GetClassCategoryToolClassNamePairs(std::vector< std::pair<QString, QString> >& categoryToolClassNamePairs) override;
-    void    GetClassTypes(const QString& category, QStringList& types);
+    void    GetClassTypes(const QString& category, QStringList& types) override;
 
     //! Export objects to xml.
     //! When onlyShared is true ony objects with shared flags exported, overwise only not shared object exported.
-    void    Export(const QString& levelPath, XmlNodeRef& rootNode, bool onlyShared);
-    void    ExportEntities(XmlNodeRef& rootNode);
+    void    Export(const QString& levelPath, XmlNodeRef& rootNode, bool onlyShared) override;
+    void    ExportEntities(XmlNodeRef& rootNode) override;
 
     //! Serialize Objects in manager to specified XML Node.
     //! @param flags Can be one of SerializeFlags.
-    void    Serialize(XmlNodeRef& rootNode, bool bLoading, int flags = SERIALIZE_ALL);
+    void    Serialize(XmlNodeRef& rootNode, bool bLoading, int flags = SERIALIZE_ALL) override;
 
-    void SerializeNameSelection(XmlNodeRef& rootNode, bool bLoading);
+    void SerializeNameSelection(XmlNodeRef& rootNode, bool bLoading) override;
 
     //! Load objects from object archive.
     //! @param bSelect if set newly loaded object will be selected.
-    void LoadObjects(CObjectArchive& ar, bool bSelect);
+    void LoadObjects(CObjectArchive& ar, bool bSelect) override;
 
     //! Delete from Object manager all objects without SHARED flag.
     void    DeleteNotSharedObjects();
@@ -276,57 +276,57 @@ public:
 
     bool AddObject(CBaseObject* obj);
     void RemoveObject(CBaseObject* obj);
-    void ChangeObjectId(REFGUID oldId, REFGUID newId);
-    bool IsDuplicateObjectName(const QString& newName) const
+    void ChangeObjectId(REFGUID oldId, REFGUID newId) override;
+    bool IsDuplicateObjectName(const QString& newName) const override
     {
         return FindObject(newName) ? true : false;
     }
-    void ShowDuplicationMsgWarning(CBaseObject* obj, const QString& newName, bool bShowMsgBox) const;
-    void ChangeObjectName(CBaseObject* obj, const QString& newName);
+    void ShowDuplicationMsgWarning(CBaseObject* obj, const QString& newName, bool bShowMsgBox) const override;
+    void ChangeObjectName(CBaseObject* obj, const QString& newName) override;
 
     //! Convert object of one type to object of another type.
     //! Original object is deleted.
-    bool ConvertToType(CBaseObject* pObject, const QString& typeName);
+    bool ConvertToType(CBaseObject* pObject, const QString& typeName) override;
 
     //! Set new selection callback.
     //! @return previous selection callback.
-    IObjectSelectCallback* SetSelectCallback(IObjectSelectCallback* callback);
+    IObjectSelectCallback* SetSelectCallback(IObjectSelectCallback* callback) override;
 
     // Enables/Disables creating of game objects.
-    void SetCreateGameObject(bool enable) { m_createGameObjects = enable; };
+    void SetCreateGameObject(bool enable) override { m_createGameObjects = enable; };
     //! Return true if objects loaded from xml should immidiatly create game objects associated with them.
-    bool IsCreateGameObjects() const { return m_createGameObjects; };
+    bool IsCreateGameObjects() const override { return m_createGameObjects; };
 
     //////////////////////////////////////////////////////////////////////////
     //! Get access to gizmo manager.
-    IGizmoManager* GetGizmoManager();
+    IGizmoManager* GetGizmoManager() override;
 
     //////////////////////////////////////////////////////////////////////////
     //! Invalidate visibily settings of objects.
-    void InvalidateVisibleList();
+    void InvalidateVisibleList() override;
 
     //////////////////////////////////////////////////////////////////////////
     // ObjectManager notification Callbacks.
     //////////////////////////////////////////////////////////////////////////
-    void AddObjectEventListener(EventListener* listener);
-    void RemoveObjectEventListener(EventListener* listener);
+    void AddObjectEventListener(EventListener* listener) override;
+    void RemoveObjectEventListener(EventListener* listener) override;
 
     //////////////////////////////////////////////////////////////////////////
     // Used to indicate starting and ending of objects loading.
     //////////////////////////////////////////////////////////////////////////
-    void StartObjectsLoading(int numObjects);
-    void EndObjectsLoading();
+    void StartObjectsLoading(int numObjects) override;
+    void EndObjectsLoading() override;
 
     //////////////////////////////////////////////////////////////////////////
     // Gathers all resources used by all objects.
-    void GatherUsedResources(CUsedResources& resources);
+    void GatherUsedResources(CUsedResources& resources) override;
 
-    virtual bool IsLightClass(CBaseObject* pObject);
+    bool IsLightClass(CBaseObject* pObject) override;
 
-    virtual void FindAndRenameProperty2(const char* property2Name, const QString& oldValue, const QString& newValue);
-    virtual void FindAndRenameProperty2If(const char* property2Name, const QString& oldValue, const QString& newValue, const char* otherProperty2Name, const QString& otherValue);
+    virtual void FindAndRenameProperty2(const char* property2Name, const QString& oldValue, const QString& newValue) override;
+    virtual void FindAndRenameProperty2If(const char* property2Name, const QString& oldValue, const QString& newValue, const char* otherProperty2Name, const QString& otherValue) override;
 
-    bool IsReloading() const { return m_bInReloading; }
+    bool IsReloading() const override { return m_bInReloading; }
     void SetSkipUpdate(bool bSkipUpdate) override { m_bSkipObjectUpdate = bSkipUpdate; }
 
     void SetExportingLevel(bool bExporting) override { m_bLevelExporting = bExporting; }
@@ -341,7 +341,7 @@ private:
     @param objectNode Xml node to serialize object info from.
     @param pUndoObject Pointer to deleted object for undo.
     */
-    CBaseObject* NewObject(CObjectArchive& archive, CBaseObject* pUndoObject, bool bMakeNewId);
+    CBaseObject* NewObject(CObjectArchive& archive, CBaseObject* pUndoObject, bool bMakeNewId) override;
 
     //! Update visibility of all objects.
     void UpdateVisibilityList();

Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.h

@@ -86,7 +86,7 @@ public:
     // Always returns false as Component entity highlighting (accenting) is taken care of elsewhere
     bool IsHighlighted() { return false; }
     // Component entity highlighting (accenting) is taken care of elsewhere
-    void DrawHighlight(DisplayContext& /*dc*/) {};
+    void DrawHighlight(DisplayContext& /*dc*/) override {};
 
     // Don't auto-clone children. Cloning happens in groups with reference fixups,
     // and individually selected objercts should be cloned as individuals.
@@ -164,7 +164,7 @@ protected:
 
     float GetRadius();
 
-    void DeleteThis() { delete this; };
+    void DeleteThis() override { delete this; };
 
     bool IsNonLayerAncestorSelected() const;
     bool IsLayer() const;

Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.h

@@ -182,7 +182,7 @@ private:
     //////////////////////////////////////////////////////////////////////////
     // AzToolsFramework::EditorContextMenu::Bus::Handler overrides
     void PopulateEditorGlobalContextMenu(QMenu* menu, const AZ::Vector2& point, int flags) override;
-    int GetMenuPosition() const;
+    int GetMenuPosition() const override;
     //////////////////////////////////////////////////////////////////////////
 
     //////////////////////////////////////////////////////////////////////////

Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/ComponentPalette/FavoriteComponentList.h

@@ -102,7 +102,7 @@ protected:
     void AddFavorites(const AZStd::vector<const AZ::SerializeContext::ClassData*>& classDataContainer) override;
     //////////////////////////////////////////////////////////////////////////
 
-    void rowsInserted(const QModelIndex& parent, int start, int end);
+    void rowsInserted(const QModelIndex& parent, int start, int end) override;
 
     // Context menu handlers
     void ShowContextMenu(const QPoint&);

Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.hxx

@@ -255,7 +255,7 @@ protected:
     bool DropMimeDataAssets(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);
     bool CanDropMimeDataAssets(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const;
 
-    QMap<int, QVariant> itemData(const QModelIndex &index) const;
+    QMap<int, QVariant> itemData(const QModelIndex &index) const override;
     QVariant dataForAll(const QModelIndex& index, int role) const;
     QVariant dataForName(const QModelIndex& index, int role) const;
     QVariant dataForVisibility(const QModelIndex& index, int role) const;

Code/Editor/PreferencesStdPages.h

@@ -28,16 +28,16 @@ public:
 
     //////////////////////////////////////////////////////////////////////////
     // IUnkown implementation.
-    virtual HRESULT STDMETHODCALLTYPE QueryInterface(const IID& riid, void** ppvObj);
-    virtual ULONG STDMETHODCALLTYPE AddRef();
-    virtual ULONG STDMETHODCALLTYPE Release();
+    HRESULT STDMETHODCALLTYPE QueryInterface(const IID& riid, void** ppvObj) override;
+    ULONG STDMETHODCALLTYPE AddRef() override;
+    ULONG STDMETHODCALLTYPE Release() override;
     //////////////////////////////////////////////////////////////////////////
 
-    virtual REFGUID ClassID();
+    REFGUID ClassID() override;
 
     //////////////////////////////////////////////////////////////////////////
-    virtual int GetPagesCount();
-    virtual IPreferencesPage* CreateEditorPreferencesPage(int index) override;
+    int GetPagesCount() override;
+    IPreferencesPage* CreateEditorPreferencesPage(int index) override;
 };
 
 #endif // CRYINCLUDE_EDITOR_PREFERENCESSTDPAGES_H

Code/Editor/QtViewPane.h

@@ -123,18 +123,18 @@ public:
     {
     }
 
-    virtual ESystemClassID SystemClassID() { return m_classId; };
+    ESystemClassID SystemClassID() override { return m_classId; };
     static const GUID& GetClassID()
     {
         return TWidget::GetClassID();
     }
 
-    virtual const GUID& ClassID()
+    const GUID& ClassID() override
     {
         return GetClassID();
     }
-    virtual QString ClassName() { return m_name; };
-    virtual QString Category() { return m_category; };
+    QString ClassName() override { return m_name; };
+    QString Category() override { return m_category; };
 
     QObject* CreateQObject() const override { return new TWidget(); };
     QString GetPaneTitle() override { return m_name; };

Code/Editor/SelectSequenceDialog.h

@@ -30,7 +30,7 @@ protected:
     void OnInitDialog() override;
 
     // Derived Dialogs should override this
-    virtual void GetItems(std::vector<SItem>& outItems);
+    void GetItems(std::vector<SItem>& outItems) override;
 };
 
 #endif // CRYINCLUDE_EDITOR_SELECTSEQUENCEDIALOG_H

Code/Editor/ToolbarCustomizationDialog.h

@@ -39,7 +39,7 @@ public:
 protected:
     void dragMoveEvent(QDragMoveEvent* ev) override;
     void dragEnterEvent(QDragEnterEvent* ev) override;
-    void dropEvent(QDropEvent* ev);
+    void dropEvent(QDropEvent* ev) override;
 
 private:
     void OnTabChanged(int index);

Code/Editor/TopRendererWnd.h

@@ -35,11 +35,11 @@ public:
 
     /** Get type of this viewport.
     */
-    virtual EViewportType GetType() const { return ET_ViewportMap; }
-    virtual void SetType(EViewportType type);
+    EViewportType GetType() const override { return ET_ViewportMap; }
+    void SetType(EViewportType type) override;
 
-    virtual void ResetContent();
-    virtual void UpdateContent(int flags);
+    void ResetContent() override;
+    void UpdateContent(int flags) override;
 
     //! Map viewport position to world space position.
     virtual Vec3    ViewToWorld(const QPoint& vp, bool* collideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const override;
@@ -52,7 +52,7 @@ public:
 
 protected:
     // Draw everything.
-    virtual void Draw(DisplayContext& dc);
+    void Draw(DisplayContext& dc) override;
 
 private:
     bool m_bContentsUpdated;

Code/Editor/TrackView/SequenceBatchRenderDialog.h

@@ -187,7 +187,7 @@ protected:
     int m_customFPS;
 
     void InitializeContext();
-    virtual void OnMovieEvent(IMovieListener::EMovieEvent event, IAnimSequence* pSequence);
+    void OnMovieEvent(IMovieListener::EMovieEvent event, IAnimSequence* pSequence) override;
 
     void CaptureItemStart();
 

Code/Editor/TrackView/TrackViewCurveEditor.h

@@ -50,8 +50,8 @@ public:
     void SetPlayCallback(const std::function<void()>& callback);
 
     // IAnimationContextListener
-    virtual void OnSequenceChanged(CTrackViewSequence* pNewSequence);
-    virtual void OnTimeChanged(float newTime);
+    void OnSequenceChanged(CTrackViewSequence* pNewSequence) override;
+    void OnTimeChanged(float newTime) override;
 
 protected:
     void showEvent(QShowEvent* event) override;
@@ -65,7 +65,7 @@ private:
     void OnSplineTimeMarkerChange();
 
     // IEditorNotifyListener
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     //ITrackViewSequenceListener
     void OnKeysChanged(CTrackViewSequence* pSequence) override;
@@ -109,8 +109,8 @@ public:
     float GetFPS() const { return m_widget->GetFPS(); }
     void SetTickDisplayMode(ETVTickMode mode) { m_widget->SetTickDisplayMode(mode); }
 
-    virtual void OnSequenceChanged(CTrackViewSequence* pNewSequence) { m_widget->OnSequenceChanged(pNewSequence); }
-    virtual void OnTimeChanged(float newTime) { m_widget->OnTimeChanged(newTime); }
+    void OnSequenceChanged(CTrackViewSequence* pNewSequence) override { m_widget->OnSequenceChanged(pNewSequence); }
+    void OnTimeChanged(float newTime) override { m_widget->OnTimeChanged(newTime); }
 
     // ITrackViewSequenceListener delegation to m_widget
     void OnKeysChanged(CTrackViewSequence* pSequence) override { m_widget->OnKeysChanged(pSequence); }

Code/Editor/TrackView/TrackViewDialog.h

@@ -69,10 +69,10 @@ public:
     void UpdateSequenceLockStatus();
 
     // IAnimationContextListener
-    virtual void OnSequenceChanged(CTrackViewSequence* pNewSequence) override;
+    void OnSequenceChanged(CTrackViewSequence* pNewSequence) override;
 
     // ITrackViewSequenceListener
-    virtual void OnSequenceSettingsChanged(CTrackViewSequence* pSequence) override;
+    void OnSequenceSettingsChanged(CTrackViewSequence* pSequence) override;
 
     void UpdateDopeSheetTime(CTrackViewSequence* pSequence);
 
@@ -197,8 +197,8 @@ private:
     bool processRawInput(MSG* pMsg);
 #endif
 
-    virtual void OnNodeSelectionChanged(CTrackViewSequence* pSequence) override;
-    virtual void OnNodeRenamed(CTrackViewNode* pNode, const char* pOldName) override;
+    void OnNodeSelectionChanged(CTrackViewSequence* pSequence) override;
+    void OnNodeRenamed(CTrackViewNode* pNode, const char* pOldName) override;
 
     void OnSequenceAdded(CTrackViewSequence* pSequence) override;
     void OnSequenceRemoved(CTrackViewSequence* pSequence) override;
@@ -209,8 +209,8 @@ private:
     void AddDialogListeners();
     void RemoveDialogListeners();
 
-    virtual void BeginUndoTransaction();
-    virtual void EndUndoTransaction();
+    void BeginUndoTransaction() override;
+    void EndUndoTransaction() override;
     void SaveCurrentSequenceToFBX();
     void SaveSequenceTimingToXML();
 

Code/Editor/TrackView/TrackViewSequence.h

@@ -100,16 +100,16 @@ public:
     void Load() override;
 
     // ITrackViewNode
-    virtual ETrackViewNodeType GetNodeType() const override { return eTVNT_Sequence; }
+    ETrackViewNodeType GetNodeType() const override { return eTVNT_Sequence; }
 
-    virtual AZStd::string GetName() const override { return m_pAnimSequence->GetName(); }
-    virtual bool SetName(const char* pName) override;
-    virtual bool CanBeRenamed() const override { return true; }
+    AZStd::string GetName() const override { return m_pAnimSequence->GetName(); }
+    bool SetName(const char* pName) override;
+    bool CanBeRenamed() const override { return true; }
 
     // Binding/Unbinding
-    virtual void BindToEditorObjects() override;
-    virtual void UnBindFromEditorObjects() override;
-    virtual bool IsBoundToEditorObjects() const override;
+    void BindToEditorObjects() override;
+    void UnBindFromEditorObjects() override;
+    bool IsBoundToEditorObjects() const override;
 
     // Time range
     void SetTimeRange(Range timeRange);
@@ -136,10 +136,10 @@ public:
     uint32 GetCryMovieId() const { return m_pAnimSequence->GetId(); }
 
     // Rendering
-    virtual void Render(const SAnimContext& animContext) override;
+    void Render(const SAnimContext& animContext) override;
 
     // Playback control
-    virtual void Animate(const SAnimContext& animContext) override;
+    void Animate(const SAnimContext& animContext) override;
     void Resume() { m_pAnimSequence->Resume(); }
     void Pause() { m_pAnimSequence->Pause(); }
     void StillUpdate() { m_pAnimSequence->StillUpdate(); }
@@ -162,7 +162,7 @@ public:
     void TimeChanged(float newTime) { m_pAnimSequence->TimeChanged(newTime); }
 
     // Check if it's a group node
-    virtual bool IsGroupNode() const override { return true; }
+    bool IsGroupNode() const override { return true; }
 
     // Track Events (TODO: Undo?)
     int GetTrackEventsCount() const      { return m_pAnimSequence->GetTrackEventsCount(); }
@@ -195,7 +195,7 @@ public:
     bool IsActiveSequence() const;
 
     // The root sequence node is always an active director
-    virtual bool IsActiveDirector() const override { return true; }
+    bool IsActiveDirector() const override { return true; }
 
     // Copy keys to clipboard (in XML form)
     void CopyKeysToClipboard(const bool bOnlySelectedKeys, const bool bOnlyFromSelectedTracks);
@@ -306,15 +306,15 @@ 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;
 
     std::deque<CTrackViewTrack*> GetMatchingTracks(CTrackViewAnimNode* pAnimNode, XmlNodeRef trackNode);
     void GetMatchedPasteLocationsRec(std::vector<TMatchedTrackLocation>& locations, CTrackViewNode* 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;
 
     // For record mode on AZ::Entities - connect (or disconnect) to buses for notification of property changes
     void ConnectToBusesForRecording(const AZ::EntityId& entityIdForBus, bool enableConnection);

Code/Editor/TrackView/TrackViewSequenceManager.h

@@ -27,7 +27,7 @@ public:
     CTrackViewSequenceManager();
     ~CTrackViewSequenceManager();
 
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
 
     unsigned int GetCount() const { return static_cast<int>(m_sequences.size()); }
 
@@ -65,7 +65,7 @@ private:
     void OnSequenceAdded(CTrackViewSequence* pSequence);
     void OnSequenceRemoved(CTrackViewSequence* pSequence);
 
-    virtual void OnDataBaseItemEvent(IDataBaseItem* pItem, EDataBaseItemEvent event);
+    void OnDataBaseItemEvent(IDataBaseItem* pItem, EDataBaseItemEvent event) override;
 
     // AZ::EntitySystemBus
     void OnEntityNameChanged(const AZ::EntityId& entityId, const AZStd::string& name) override;

Code/Editor/TrackView/TrackViewSplineCtrl.h

@@ -28,7 +28,7 @@ public:
     CTrackViewSplineCtrl(QWidget* parent);
     virtual ~CTrackViewSplineCtrl();
 
-    virtual void ClearSelection();
+    void ClearSelection() override;
 
     void AddSpline(ISplineInterpolator* pSpline, CTrackViewTrack* pTrack, const QColor& color);
     void AddSpline(ISplineInterpolator * pSpline, CTrackViewTrack * pTrack, QColor anColorArray[4]);
@@ -53,12 +53,12 @@ protected:
     void wheelEvent(QWheelEvent* event) override;
 
 private:
-    virtual void SelectKey(ISplineInterpolator* pSpline, int nKey, int nDimension, bool bSelect) override;
-    virtual void SelectRectangle(const QRect& rc, bool bSelect) override;
+    void SelectKey(ISplineInterpolator* pSpline, int nKey, int nDimension, bool bSelect) override;
+    void SelectRectangle(const QRect& rc, bool bSelect) override;
 
     std::vector<CTrackViewTrack*> m_tracks;
 
-    virtual bool GetTangentHandlePts(QPoint& inTangentPt, QPoint& pt, QPoint& outTangentPt,
+    bool GetTangentHandlePts(QPoint& inTangentPt, QPoint& pt, QPoint& outTangentPt,
         int nSpline, int nKey, int nDimension) override;
     void ComputeIncomingTangentAndEaseTo(float& ds, float& easeTo, QPoint inTangentPt,
         int nSpline, int nKey, int nDimension);
@@ -67,7 +67,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);
+    virtual ISplineCtrlUndo* CreateSplineCtrlUndoObject(std::vector<ISplineInterpolator*>& splineContainer) override;
 
     bool m_bKeysFreeze;
     bool m_bTangentsFreeze;

Code/Editor/Util/ColumnGroupTreeView.h

@@ -44,7 +44,7 @@ public slots:
     QVector<int> Groups() const;
 
 protected:
-    void paintEvent(QPaintEvent* event)
+    void paintEvent(QPaintEvent* event) override
     {
         if (model() && model()->rowCount() > 0)
         {

Code/Editor/Util/Variable.h

@@ -399,7 +399,7 @@ public:
     //! Get name of parameter.
     QString GetDescription() const override { return m_description; };
 
-    EType   GetType() const { return IVariable::UNKNOWN; };
+    EType   GetType() const override { return IVariable::UNKNOWN; };
     int GetSize() const override { return sizeof(*this); };
 
     unsigned char   GetDataType() const override { return m_dataType; };
@@ -409,8 +409,8 @@ public:
     int  GetFlags() const override { return m_flags; }
     void  SetFlagRecursive(EFlags flag) override { m_flags |= flag; }
 
-    void SetUserData(const QVariant &data){ m_userData = data; };
-    QVariant GetUserData() const { return m_userData; }
+    void SetUserData(const QVariant &data) override { m_userData = data; };
+    QVariant GetUserData() const override { return m_userData; }
 
     //////////////////////////////////////////////////////////////////////////
     // Set methods.
@@ -1114,44 +1114,44 @@ public:
     }
 
     //! Get name of parameter.
-    virtual EType   GetType() const { return (EType)var_type::type_traits<T>::type(); };
-    virtual int     GetSize() const { return sizeof(T); };
+    EType   GetType() const override { return (EType)var_type::type_traits<T>::type(); };
+    int     GetSize() const override { return sizeof(T); };
 
     //////////////////////////////////////////////////////////////////////////
     // Set methods.
     //////////////////////////////////////////////////////////////////////////
-    virtual void Set(int value)                           { SetValue(value); }
-    virtual void Set(bool value)                      { SetValue(value); }
-    virtual void Set(float value)                     { SetValue(value); }
-    virtual void Set(double value)                { SetValue(value); }
-    virtual void Set(const Vec2& value)           { SetValue(value); }
-    virtual void Set(const Vec3& value)           { SetValue(value); }
-    virtual void Set(const Vec4& value)           { SetValue(value); }
-    virtual void Set(const Ang3& value)           { SetValue(value); }
-    virtual void Set(const Quat& value)           { SetValue(value); }
-    virtual void Set(const QString& value)    { SetValue(value); }
-    virtual void Set(const char* value)      { SetValue(QString(value)); }
+    void Set(int value) override                           { SetValue(value); }
+    void Set(bool value) override                      { SetValue(value); }
+    void Set(float value) override                     { SetValue(value); }
+    void Set(double value) override                { SetValue(value); }
+    void Set(const Vec2& value) override           { SetValue(value); }
+    void Set(const Vec3& value) override           { SetValue(value); }
+    void Set(const Vec4& value) override           { SetValue(value); }
+    void Set(const Ang3& value) override           { SetValue(value); }
+    void Set(const Quat& value) override           { SetValue(value); }
+    void Set(const QString& value) override    { SetValue(value); }
+    void Set(const char* value) override      { SetValue(QString(value)); }
 
     //////////////////////////////////////////////////////////////////////////
     // Get methods.
     //////////////////////////////////////////////////////////////////////////
-    virtual void Get(int& value) const                        { GetValue(value); }
-    virtual void Get(bool& value) const                   { GetValue(value); }
-    virtual void Get(float& value) const                  { GetValue(value); }
-    virtual void Get(double& value) const                  { GetValue(value); }
-    virtual void Get(Vec2& value) const                   { GetValue(value); }
-    virtual void Get(Vec3& value) const                   { GetValue(value); }
-    virtual void Get(Vec4& value) const                   { GetValue(value); }
-    virtual void Get(Quat& value) const                   { GetValue(value); }
-    virtual void Get(QString& value) const                { GetValue(value); }
-    virtual bool HasDefaultValue() const
+    void Get(int& value) const override                        { GetValue(value); }
+    void Get(bool& value) const override                   { GetValue(value); }
+    void Get(float& value) const override                  { GetValue(value); }
+    void Get(double& value) const override                  { GetValue(value); }
+    void Get(Vec2& value) const override                   { GetValue(value); }
+    void Get(Vec3& value) const override                   { GetValue(value); }
+    void Get(Vec4& value) const override                   { GetValue(value); }
+    void Get(Quat& value) const override                   { GetValue(value); }
+    void Get(QString& value) const override                { GetValue(value); }
+    bool HasDefaultValue() const override
     {
         T defval;
         var_type::init(defval);
         return m_valueDef == defval;
     }
 
-    virtual void ResetToDefault()
+    void ResetToDefault() override
     {
         T defval;
         var_type::init(defval);
@@ -1161,7 +1161,7 @@ public:
     //////////////////////////////////////////////////////////////////////////
     // Limits.
     //////////////////////////////////////////////////////////////////////////
-    virtual void SetLimits(float fMin, float fMax, float fStep = 0.f, bool bHardMin = true, bool bHardMax = true)
+    void SetLimits(float fMin, float fMax, float fStep = 0.f, bool bHardMin = true, bool bHardMax = true) override
     {
         m_valueMin = fMin;
         m_valueMax = fMax;
@@ -1173,7 +1173,7 @@ public:
         m_customLimits = true;
     }
 
-    virtual void GetLimits(float& fMin, float& fMax, float& fStep, bool& bHardMin, bool& bHardMax)
+    void GetLimits(float& fMin, float& fMax, float& fStep, bool& bHardMin, bool& bHardMax) override
     {
         if (!m_customLimits && var_type::type_traits<T>::supports_range())
         {
@@ -1201,7 +1201,7 @@ public:
         m_customLimits = false;
     }
 
-    virtual bool HasCustomLimits()
+    bool HasCustomLimits() override
     {
         return m_customLimits;
     }
@@ -1219,14 +1219,14 @@ public:
     void operator=(const T& value) { SetValue(value); }
 
     //////////////////////////////////////////////////////////////////////////
-    IVariable* Clone([[maybe_unused]] bool bRecursive) const
+    IVariable* Clone([[maybe_unused]] bool bRecursive) const override
     {
         Self* var = new Self(*this);
         return var;
     }
 
     //////////////////////////////////////////////////////////////////////////
-    void CopyValue(IVariable* fromVar)
+    void CopyValue(IVariable* fromVar) override
     {
         assert(fromVar);
         T val;
@@ -1670,7 +1670,7 @@ struct CSmartVariableBase
         return *pV;
     }                                                        // Cast to CVariableBase&
     VarType& operator*() const { return *pVar; }
-    VarType* operator->(void) const { return pVar; }
+    VarType* operator->() const { return pVar; }
 
     VarType* GetVar() const { return pVar; };
 
@@ -1732,7 +1732,7 @@ struct CSmartVariableArray
     }
 
     VarType& operator*() const { return *pVar; }
-    VarType* operator->(void) const { return pVar; }
+    VarType* operator->() const { return pVar; }
 
     VarType* GetVar() const { return pVar; };
 
@@ -1754,35 +1754,35 @@ public:
     // Dtor.
     virtual ~CVarBlock() {}
     //! Add variable to block.
-    virtual void AddVariable(IVariable* var);
+    void AddVariable(IVariable* var) override;
     //! Remove variable from block
-    virtual bool DeleteVariable(IVariable* var, bool bRecursive = false);
+    bool DeleteVariable(IVariable* var, bool bRecursive = false) override;
 
     void AddVariable(IVariable* pVar, const char* varName, unsigned char dataType = IVariable::DT_SIMPLE);
     // This used from smart variable pointer.
     void AddVariable(CVariableBase& var, const char* varName, unsigned char dataType = IVariable::DT_SIMPLE);
 
     //! Returns number of variables in block.
-    virtual int GetNumVariables() const { return static_cast<int>(m_vars.size()); }
+    int GetNumVariables() const override { return static_cast<int>(m_vars.size()); }
 
     //! Get pointer to stored variable by index.
-    virtual IVariable* GetVariable(int index) const
+    IVariable* GetVariable(int index) const override
     {
         assert(index >= 0 && index < m_vars.size());
         return m_vars[index];
     }
 
     // Clear all vars from VarBlock.
-    virtual void DeleteAllVariables() { m_vars.clear(); };
+    void DeleteAllVariables() override { m_vars.clear(); };
 
     //! Return true if variable block is empty (Does not have any vars).
-    virtual bool IsEmpty() const { return m_vars.empty(); }
+    bool IsEmpty() const override { return m_vars.empty(); }
 
     // Returns true if var block contains specified variable.
-    virtual bool IsContainsVariable(IVariable* pVar, bool bRecursive = true) const;
+    bool IsContainsVariable(IVariable* pVar, bool bRecursive = true) const override;
 
     //! Find variable by name.
-    virtual IVariable* FindVariable(const char* name, bool bRecursive = true, bool bHumanName = false) const;
+    IVariable* FindVariable(const char* name, bool bRecursive = true, bool bHumanName = false) const override;
 
     //////////////////////////////////////////////////////////////////////////
     //! Clone var block.

Code/Editor/Viewport.h

@@ -172,7 +172,7 @@ public:
 
     //! Get current view matrix.
     //! This is a matrix that transforms from world space to view space.
-    virtual const Matrix34& GetViewTM() const
+    const Matrix34& GetViewTM() const override
     {
         AZ_Error("CryLegacy", false, "QtViewport::GetViewTM not implemented");
         static const Matrix34 m;
@@ -182,7 +182,7 @@ public:
     //////////////////////////////////////////////////////////////////////////
     //! Get current screen matrix.
     //! Screen matrix transform from World space to Screen space.
-    virtual const Matrix34& GetScreenTM() const
+    const Matrix34& GetScreenTM() const override
     {
         return m_screenTM;
     }
@@ -190,9 +190,9 @@ public:
     virtual Vec3 MapViewToCP(const QPoint& point) = 0;
 
     //! Map viewport position to world space position.
-    virtual Vec3        ViewToWorld(const QPoint& vp, bool* pCollideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const = 0;
+    Vec3        ViewToWorld(const QPoint& vp, bool* pCollideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const override = 0;
     //! Convert point on screen to world ray.
-    virtual void        ViewToWorldRay(const QPoint& vp, Vec3& raySrc, Vec3& rayDir) const = 0;
+    void        ViewToWorldRay(const QPoint& vp, Vec3& raySrc, Vec3& rayDir) const override = 0;
     //! Get normal for viewport position
     virtual Vec3        ViewToWorldNormal(const QPoint& vp, bool onlyTerrain, bool bTestRenderMesh = false) = 0;
 
@@ -261,7 +261,7 @@ public:
     virtual void SetCursorString(const QString& str) = 0;
 
     virtual void SetFocus() = 0;
-    virtual void Invalidate(bool bErase = 1) = 0;
+    virtual void Invalidate(bool bErase = true) = 0;
 
     // Is overridden by RenderViewport
     virtual void SetFOV([[maybe_unused]] float fov) {}
@@ -280,7 +280,7 @@ public:
     virtual void PreWidgetRendering() {}
     virtual void PostWidgetRendering() {}
 
-    virtual CViewport *asCViewport() { return this; }
+    CViewport *asCViewport() override { return this; }
 
 protected:
     CLayoutViewPane* m_viewPane = nullptr;
@@ -342,7 +342,7 @@ public:
     void SetActiveWindow() override { activateWindow(); }
 
     //! Called while window is idle.
-    virtual void Update();
+    void Update() override;
 
     /** Set name of this viewport.
     */
@@ -350,24 +350,24 @@ public:
 
     /** Get name of viewport
     */
-    QString GetName() const;
+    QString GetName() const override;
 
-    virtual void SetFocus() { setFocus(); }
-    virtual void Invalidate([[maybe_unused]] bool bErase = 1) { update(); }
+    void SetFocus() override { setFocus(); }
+    void Invalidate([[maybe_unused]] bool bErase = 1) override { update(); }
 
     // Is overridden by RenderViewport
-    virtual void SetFOV([[maybe_unused]] float fov) {}
-    virtual float GetFOV() const;
+    void SetFOV([[maybe_unused]] float fov) override {}
+    float GetFOV() const override;
 
     // Must be overridden in derived classes.
     // Returns:
     //   e.g. 4.0/3.0
-    virtual float GetAspectRatio() const = 0;
-    virtual void GetDimensions(int* pWidth, int* pHeight) const;
-    virtual void ScreenToClient(QPoint& pPoint) const override;
+    float GetAspectRatio() const override = 0;
+    void GetDimensions(int* pWidth, int* pHeight) const override;
+    void ScreenToClient(QPoint& pPoint) const override;
 
-    virtual void ResetContent();
-    virtual void UpdateContent(int flags);
+    void ResetContent() override;
+    void UpdateContent(int flags) override;
 
     //! Set current zoom factor for this viewport.
     virtual void SetZoomFactor(float fZoomFactor);
@@ -379,10 +379,10 @@ public:
     virtual void OnDeactivate();
 
     //! Map world space position to viewport position.
-    virtual QPoint   WorldToView(const Vec3& wp) const override;
+    QPoint WorldToView(const Vec3& wp) const override;
 
     //! Map world space position to 3D viewport position.
-    virtual Vec3    WorldToView3D(const Vec3& wp, int nFlags = 0) const;
+    Vec3 WorldToView3D(const Vec3& wp, int nFlags = 0) const override;
 
     //! Map viewport position to world space position.
     virtual Vec3 ViewToWorld(const QPoint& vp, bool* pCollideWithTerrain = nullptr, bool onlyTerrain = false, bool bSkipVegetation = false, bool bTestRenderMesh = false, bool* collideWithObject = nullptr) const override;
@@ -398,17 +398,17 @@ public:
     //! This method return a vector (p2-p1) in world space alligned to construction plane and restriction axises.
     //! p1 and p2 must be given in world space and lie on construction plane.
     using CViewport::GetCPVector;
-    virtual Vec3 GetCPVector(const Vec3& p1, const Vec3& p2, int axis);
+    Vec3 GetCPVector(const Vec3& p1, const Vec3& p2, int axis) override;
 
     //! Snap any given 3D world position to grid lines if snap is enabled.
     Vec3 SnapToGrid(const Vec3& vec) override;
-    virtual float GetGridStep() const;
+    float GetGridStep() const override;
 
     //! Returns the screen scale factor for a point given in world coordinates.
     //! This factor gives the width in world-space units at the point's distance of the viewport.
-    virtual float GetScreenScaleFactor([[maybe_unused]] const Vec3& worldPoint) const { return 1; };
+    float GetScreenScaleFactor([[maybe_unused]] const Vec3& worldPoint) const  override { return 1; };
 
-    void SetAxisConstrain(int axis);
+    void SetAxisConstrain(int axis) override;
 
     /// Take raw input and create a final mouse interaction.
     /// @attention Do not map **point** from widget to viewport explicitly,
@@ -420,7 +420,7 @@ public:
     // Selection.
     //////////////////////////////////////////////////////////////////////////
     //! Resets current selection region.
-    virtual void ResetSelectionRegion();
+    void ResetSelectionRegion() override;
     //! Set 2D selection rectangle.
     void SetSelectionRectangle(const QRect& rect) override;
 
@@ -429,12 +429,12 @@ public:
     //! Called when dragging selection rectangle.
     void OnDragSelectRectangle(const QRect& rect, bool bNormalizeRect = false) override;
     //! Get selection procision tolerance.
-    float GetSelectionTolerance() const { return m_selectionTolerance; }
+    float GetSelectionTolerance() const override { return m_selectionTolerance; }
     //! Center viewport on selection.
     void CenterOnSelection() override {}
     void CenterOnAABB([[maybe_unused]] const AABB& aabb) override {}
 
-    virtual void CenterOnSliceInstance() {}
+    void CenterOnSliceInstance() override {}
 
     //! Performs hit testing of 2d point in view to find which object hit.
     bool HitTest(const QPoint& point, HitContext& hitInfo) override;
@@ -447,10 +447,10 @@ public:
     float GetDistanceToLine(const Vec3& lineP1, const Vec3& lineP2, const QPoint& point) const override;
 
     // Access to the member m_bAdvancedSelectMode so interested modules can know its value.
-    bool GetAdvancedSelectModeFlag();
+    bool GetAdvancedSelectModeFlag() override;
 
-    virtual void GetPerpendicularAxis(EAxis* pAxis, bool* pIs2D) const;
-    virtual const ::Plane* GetConstructionPlane() const { return &m_constructionPlane; }
+    void GetPerpendicularAxis(EAxis* pAxis, bool* pIs2D) const override;
+    const ::Plane* GetConstructionPlane() const override { return &m_constructionPlane; }
 
     //////////////////////////////////////////////////////////////////////////
 
@@ -458,7 +458,7 @@ public:
     //! Set construction plane from given position construction matrix refrence coord system and axis settings.
     //////////////////////////////////////////////////////////////////////////
     void MakeConstructionPlane(int axis) override;
-    virtual void SetConstructionMatrix(RefCoordSys coordSys, const Matrix34& xform);
+    void SetConstructionMatrix(RefCoordSys coordSys, const Matrix34& xform) override;
     virtual const Matrix34& GetConstructionMatrix(RefCoordSys coordSys);
     // Set simple construction plane origin.
     void SetConstructionOrigin(const Vec3& worldPos);
@@ -468,11 +468,11 @@ public:
 
     //////////////////////////////////////////////////////////////////////////
     // Undo for viewpot operations.
-    void BeginUndo();
-    void AcceptUndo(const QString& undoDescription);
-    void CancelUndo();
-    void RestoreUndo();
-    bool IsUndoRecording() const;
+    void BeginUndo() override;
+    void AcceptUndo(const QString& undoDescription) override;
+    void CancelUndo() override;
+    void RestoreUndo() override;
+    bool IsUndoRecording() const override;
     //////////////////////////////////////////////////////////////////////////
 
     //! Get prefered original size for this viewport.
@@ -480,39 +480,39 @@ public:
     virtual QSize GetIdealSize() const;
 
     //! Check if world space bounding box is visible in this view.
-    virtual bool IsBoundsVisible(const AABB& box) const;
+    bool IsBoundsVisible(const AABB& box) const override;
 
     //////////////////////////////////////////////////////////////////////////
 
-    void SetCursor(const QCursor& cursor)
+    void SetCursor(const QCursor& cursor) override
     {
         setCursor(cursor);
     }
 
     // Set`s current cursor string.
     void SetCurrentCursor(const QCursor& hCursor, const QString& cursorString);
-    virtual void SetCurrentCursor(EStdCursor stdCursor, const QString& cursorString);
-    void SetCurrentCursor(EStdCursor stdCursor);
-    virtual void SetCursorString(const QString& cursorString);
-    void ResetCursor();
-    void SetSupplementaryCursorStr(const QString& str);
+    void SetCurrentCursor(EStdCursor stdCursor, const QString& cursorString) override;
+    void SetCurrentCursor(EStdCursor stdCursor) override;
+    void SetCursorString(const QString& cursorString) override;
+    void ResetCursor() override;
+    void SetSupplementaryCursorStr(const QString& str) override;
 
     //////////////////////////////////////////////////////////////////////////
     // Return visble objects cache.
-    CBaseObjectsCache* GetVisibleObjectsCache() { return m_pVisibleObjectsCache; };
+    CBaseObjectsCache* GetVisibleObjectsCache()  override { return m_pVisibleObjectsCache; };
 
-    void RegisterRenderListener(IRenderListener*    piListener);
-    bool UnregisterRenderListener(IRenderListener*  piListener);
-    bool IsRenderListenerRegistered(IRenderListener*    piListener);
+    void RegisterRenderListener(IRenderListener*    piListener) override;
+    bool UnregisterRenderListener(IRenderListener*  piListener) override;
+    bool IsRenderListenerRegistered(IRenderListener*    piListener) override;
 
-    void AddPostRenderer(IPostRenderer* pPostRenderer);
-    bool RemovePostRenderer(IPostRenderer* pPostRenderer);
+    void AddPostRenderer(IPostRenderer* pPostRenderer) override;
+    bool RemovePostRenderer(IPostRenderer* pPostRenderer) override;
 
     void CaptureMouse() override { m_mouseCaptured = true;  QWidget::grabMouse(); }
     void ReleaseMouse() override { m_mouseCaptured = false;  QWidget::releaseMouse(); }
 
-    virtual void setRay(QPoint& vp, Vec3& raySrc, Vec3& rayDir);
-    virtual void setHitcontext(QPoint& vp, Vec3& raySrc, Vec3& rayDir);
+    void setRay(QPoint& vp, Vec3& raySrc, Vec3& rayDir) override;
+    void setHitcontext(QPoint& vp, Vec3& raySrc, Vec3& rayDir) override;
     QPoint m_vp;
     AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
     Vec3 m_raySrc;
@@ -576,8 +576,8 @@ protected:
     //Child classes can override these to provide extra logic that wraps
     //widget rendering. Needed by the RenderViewport to handle raycasts
     //from screen-space to world-space.
-    virtual void PreWidgetRendering() {}
-    virtual void PostWidgetRendering() {}
+    void PreWidgetRendering() override {}
+    void PostWidgetRendering() override {}
 
     AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
     AzToolsFramework::ViewportUi::ViewportUiManager m_viewportUi;

Code/Editor/ViewportTitleDlg.h

@@ -77,7 +77,7 @@ Q_SIGNALS:
 protected:
     virtual void OnInitDialog();
 
-    virtual void OnEditorNotifyEvent(EEditorNotifyEvent event);
+    void OnEditorNotifyEvent(EEditorNotifyEvent event) override;
     void OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam) override;
 
     void OnMaximize();