Second round of override checks

Exposed some more functions:
getArchiveName returning name (path) of archive
getColor and getColorHSL for color select dialog
get/setDoubleClickTime in device for setting the time offset necessary to have two separate clicks instead of a double-click

Removed deprecated getXJoint and getMS3DJoint functions

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@4545 dfc29bdd-3216-0410-991c-e03cc46cb475

include/IFileArchive.h

@@ -75,6 +75,9 @@ public:
 	//! get the archive type
 	virtual E_FILE_ARCHIVE_TYPE getType() const { return EFAT_UNKNOWN; }
 
+	//! return the name (id) of the file Archive
+	virtual const io::path& getArchiveName() const =0;
+
 	//! An optionally used password string
 	/** This variable is publicly accessible from the interface in order to
 	avoid single access patterns to this place, and hence allow some more

include/IGUIColorSelectDialog.h

@@ -20,6 +20,13 @@ namespace gui
 		//! constructor
 		IGUIColorSelectDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
 			: IGUIElement(EGUIET_COLOR_SELECT_DIALOG, environment, parent, id, rectangle) {}
+
+		//! get chosen color as usual SColor struct
+		virtual video::SColor getColor() =0;
+
+		//! get chosen color as HSL values
+		virtual video::SColorHSL getColorHSL() =0;
+
 	};
 
 

include/IrrlichtDevice.h

@@ -257,6 +257,18 @@ namespace irr
 		virtual bool getGammaRamp(f32 &red, f32 &green, f32 &blue,
 					f32 &brightness, f32 &contrast) =0;
 
+		//! Set the maximal elapsed time between 2 clicks to generate doubleclicks for the mouse. It also affects tripleclick behavior.
+		/** When set to 0 no double- and tripleclicks will be generated.
+		\param timeMs maximal time in milliseconds for two consecutive clicks to be recognized as double click
+		*/
+		virtual void setDoubleClickTime(u32 timeMs) =0;
+
+		//! Get the maximal elapsed time between 2 clicks to generate double- and tripleclicks for the mouse.
+		/** When return value is 0 no double- and tripleclicks will be generated.
+		\return maximal time in milliseconds for two consecutive clicks to be recognized as double click
+		*/
+		virtual u32 getDoubleClickTime() const =0;
+
 		//! Remove messages pending in the system message loop
 		/** This function is usually used after messages have been buffered for a longer time, for example
 		when loading a large scene. Clearing the message loop prevents that mouse- or buttonclicks which users

source/Irrlicht/C3DSMeshFileLoader.h

@@ -30,13 +30,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".cob")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! creates/loads an animated mesh from the file.
 	//! \return Pointer to the created mesh. Returns 0 if loading failed.
 	//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
 	//! See IReferenceCounted::drop() for more information.
-	virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+	virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CAnimatedMeshHalfLife.h

@@ -485,32 +485,32 @@ namespace scene
 		virtual ~CAnimatedMeshHalfLife();
 
 		//! loads a Halflife mdl file
-		virtual bool loadModelFile( io::IReadFile* file, ISceneManager * smgr );
+		bool loadModelFile( io::IReadFile* file, ISceneManager * smgr );
 
 		//IAnimatedMesh
-		virtual u32 getFrameCount() const;
-		virtual IMesh* getMesh(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop);
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
-		virtual E_ANIMATED_MESH_TYPE getMeshType() const;
-		virtual void renderModel ( u32 param, video::IVideoDriver * driver, const core::matrix4 &absoluteTransformation);
+		virtual u32 getFrameCount() const _IRR_OVERRIDE_;
+		virtual IMesh* getMesh(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop) _IRR_OVERRIDE_;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
+		virtual E_ANIMATED_MESH_TYPE getMeshType() const _IRR_OVERRIDE_;
+		void renderModel ( u32 param, video::IVideoDriver * driver, const core::matrix4 &absoluteTransformation);
 
 		//! returns amount of mesh buffers.
-		virtual u32 getMeshBufferCount() const;
+		virtual u32 getMeshBufferCount() const _IRR_OVERRIDE_;
 		//! returns pointer to a mesh buffer
-		virtual IMeshBuffer* getMeshBuffer(u32 nr) const;
+		virtual IMeshBuffer* getMeshBuffer(u32 nr) const _IRR_OVERRIDE_;
 		//! Returns pointer to a mesh buffer which fits a material
-		virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const;
+		virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const _IRR_OVERRIDE_;
 
-		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue);
+		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) _IRR_OVERRIDE_;
 
 		//! set the hardware mapping hint, for driver
-		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 		//! flags the meshbuffer as changed, reloads hardware buffers
-		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 		//! set user axis aligned bounding box
-		virtual void setBoundingBox(const core::aabbox3df& box);
+		virtual void setBoundingBox(const core::aabbox3df& box) _IRR_OVERRIDE_;
 
 		//! Gets the default animation speed of the animated mesh.
 		/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
@@ -609,14 +609,14 @@ namespace scene
 
 		//! returns true if the file maybe is able to be loaded by this class
 		/** based on the file extension (e.g. ".bsp") */
-		virtual bool isALoadableFileExtension(const io::path& filename) const;
+		virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 		//! creates/loads an animated mesh from the file.
 		/** \return Pointer to the created mesh. Returns 0 if loading failed.
 		If you no longer need the mesh, you should call IAnimatedMesh::drop().
 		See IReferenceCounted::drop() for more information.
 		*/
-		virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+		virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 	private:
 		scene::ISceneManager* SceneManager;

source/Irrlicht/CAnimatedMeshMD2.h

@@ -29,7 +29,7 @@ namespace scene
 		virtual ~CAnimatedMeshMD2();
 
 		//! returns the amount of frames. If the amount is 1, it is a static (=non animated) mesh.
-		virtual u32 getFrameCount() const;
+		virtual u32 getFrameCount() const _IRR_OVERRIDE_;
 
 		//! Gets the default animation speed of the animated mesh.
 		/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
@@ -47,37 +47,37 @@ namespace scene
 		}
 
 		//! returns the animated mesh based on a detail level. 0 is the lowest, 255 the highest detail. Note, that some Meshes will ignore the detail level.
-		virtual IMesh* getMesh(s32 frame, s32 detailLevel=255, s32 startFrameLoop=-1, s32 endFrameLoop=-1);
+		virtual IMesh* getMesh(s32 frame, s32 detailLevel=255, s32 startFrameLoop=-1, s32 endFrameLoop=-1) _IRR_OVERRIDE_;
 
 		//! returns amount of mesh buffers.
-		virtual u32 getMeshBufferCount() const;
+		virtual u32 getMeshBufferCount() const _IRR_OVERRIDE_;
 
 		//! returns pointer to a mesh buffer
-		virtual IMeshBuffer* getMeshBuffer(u32 nr) const;
+		virtual IMeshBuffer* getMeshBuffer(u32 nr) const _IRR_OVERRIDE_;
 
 		//! Returns pointer to a mesh buffer which fits a material
 		/** \param material: material to search for
 		\return Returns the pointer to the mesh buffer or
 		NULL if there is no such mesh buffer. */
-		virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const;
+		virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const _IRR_OVERRIDE_;
 
 		//! returns an axis aligned bounding box
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! set user axis aligned bounding box
-		virtual void setBoundingBox( const core::aabbox3df& box);
+		virtual void setBoundingBox( const core::aabbox3df& box) _IRR_OVERRIDE_;
 
 		//! sets a flag of all contained materials to a new value
-		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue);
+		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) _IRR_OVERRIDE_;
 
 		//! set the hardware mapping hint, for driver
-		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 		//! flags the meshbuffer as changed, reloads hardware buffers
-		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 		//! Returns the type of the animated mesh.
-		virtual E_ANIMATED_MESH_TYPE getMeshType() const;
+		virtual E_ANIMATED_MESH_TYPE getMeshType() const _IRR_OVERRIDE_;
 
 		//! Returns frame loop data for a special MD2 animation type.
 		virtual void getFrameLoop(EMD2_ANIMATION_TYPE,
@@ -88,11 +88,11 @@ namespace scene
 			s32& outBegin, s32& outEnd, s32& outFps) const;
 
 		//! Returns amount of md2 animations in this file.
-		virtual s32 getAnimationCount() const;
+		virtual s32 getAnimationCount() const _IRR_OVERRIDE_;
 
 		//! Returns name of md2 animation.
 		//! \param nr: Zero based index of animation.
-		virtual const c8* getAnimationName(s32 nr) const;
+		virtual const c8* getAnimationName(s32 nr) const _IRR_OVERRIDE_;
 
 
 		//

source/Irrlicht/CAnimatedMeshMD3.h

@@ -34,12 +34,12 @@ namespace scene
 				io::IFileSystem* fs, video::IVideoDriver* driver);
 
 		// IAnimatedMeshMD3
-		virtual void setInterpolationShift(u32 shift, u32 loopMode);
-		virtual SMD3Mesh* getOriginalMesh();
-		virtual SMD3QuaternionTagList* getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop);
+		virtual void setInterpolationShift(u32 shift, u32 loopMode) _IRR_OVERRIDE_;
+		virtual SMD3Mesh* getOriginalMesh() _IRR_OVERRIDE_;
+		virtual SMD3QuaternionTagList* getTagList(s32 frame, s32 detailLevel, s32 startFrameLoop, s32 endFrameLoop) _IRR_OVERRIDE_;
 
 		//IAnimatedMesh
-		virtual u32 getFrameCount() const;
+		virtual u32 getFrameCount() const _IRR_OVERRIDE_;
 
 		//! Gets the default animation speed of the animated mesh.
 		/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
@@ -58,28 +58,28 @@ namespace scene
 
 		virtual IMesh* getMesh(s32 frame, s32 detailLevel,
 				s32 startFrameLoop, s32 endFrameLoop);
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
-		virtual E_ANIMATED_MESH_TYPE getMeshType() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
+		virtual E_ANIMATED_MESH_TYPE getMeshType() const _IRR_OVERRIDE_;
 
 		//! returns amount of mesh buffers.
-		virtual u32 getMeshBufferCount() const;
+		virtual u32 getMeshBufferCount() const _IRR_OVERRIDE_;
 
 		//! returns pointer to a mesh buffer
-		virtual IMeshBuffer* getMeshBuffer(u32 nr) const;
+		virtual IMeshBuffer* getMeshBuffer(u32 nr) const _IRR_OVERRIDE_;
 
 		//! Returns pointer to a mesh buffer which fits a material
-		virtual IMeshBuffer* getMeshBuffer(const video::SMaterial &material) const;
+		virtual IMeshBuffer* getMeshBuffer(const video::SMaterial &material) const _IRR_OVERRIDE_;
 
-		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue);
+		virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) _IRR_OVERRIDE_;
 
 		//! set user axis aligned bounding box
-		virtual void setBoundingBox(const core::aabbox3df& box);
+		virtual void setBoundingBox(const core::aabbox3df& box) _IRR_OVERRIDE_;
 
 		//! set the hardware mapping hint, for driver
-		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 		//! flags the meshbuffer as changed, reloads hardware buffers
-		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX);
+		virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_;
 
 	private:
 		//! animates one frame

source/Irrlicht/CAnimatedMeshSceneNode.cpp

@@ -646,21 +646,6 @@ u32 CAnimatedMeshSceneNode::getJointCount() const
 }
 
 
-//! Returns a pointer to a child node, which has the same transformation as
-//! the corresponding joint, if the mesh in this scene node is a ms3d mesh.
-ISceneNode* CAnimatedMeshSceneNode::getMS3DJointNode(const c8* jointName)
-{
-	return  getJointNode(jointName);
-}
-
-
-//! Returns a pointer to a child node, which has the same transformation as
-//! the corresponding joint, if the mesh in this scene node is a .x mesh.
-ISceneNode* CAnimatedMeshSceneNode::getXJointNode(const c8* jointName)
-{
-	return  getJointNode(jointName);
-}
-
 //! Removes a child from this scene node.
 //! Implemented here, to be able to remove the shadow properly, if there is one,
 //! or to remove attached childs.

source/Irrlicht/CAnimatedMeshSceneNode.h

@@ -31,50 +31,50 @@ namespace scene
 		virtual ~CAnimatedMeshSceneNode();
 
 		//! sets the current frame. from now on the animation is played from this frame.
-		virtual void setCurrentFrame(f32 frame);
+		virtual void setCurrentFrame(f32 frame) _IRR_OVERRIDE_;
 
 		//! frame
-		virtual void OnRegisterSceneNode();
+		virtual void OnRegisterSceneNode() _IRR_OVERRIDE_;
 
 		//! OnAnimate() is called just before rendering the whole scene.
-		virtual void OnAnimate(u32 timeMs);
+		virtual void OnAnimate(u32 timeMs) _IRR_OVERRIDE_;
 
 		//! renders the node.
-		virtual void render();
+		virtual void render() _IRR_OVERRIDE_;
 
 		//! returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! sets the frames between the animation is looped.
 		//! the default is 0 - MaximalFrameCount of the mesh.
-		virtual bool setFrameLoop(s32 begin, s32 end);
+		virtual bool setFrameLoop(s32 begin, s32 end) _IRR_OVERRIDE_;
 
 		//! Sets looping mode which is on by default. If set to false,
 		//! animations will not be looped.
-		virtual void setLoopMode(bool playAnimationLooped);
+		virtual void setLoopMode(bool playAnimationLooped) _IRR_OVERRIDE_;
 
 		//! returns the current loop mode
-		virtual bool getLoopMode() const;
+		virtual bool getLoopMode() const _IRR_OVERRIDE_;
 
 		//! Sets a callback interface which will be called if an animation
 		//! playback has ended. Set this to 0 to disable the callback again.
-		virtual void setAnimationEndCallback(IAnimationEndCallBack* callback=0);
+		virtual void setAnimationEndCallback(IAnimationEndCallBack* callback=0) _IRR_OVERRIDE_;
 
 		//! sets the speed with which the animation is played
-		virtual void setAnimationSpeed(f32 framesPerSecond);
+		virtual void setAnimationSpeed(f32 framesPerSecond) _IRR_OVERRIDE_;
 
 		//! gets the speed with which the animation is played
-		virtual f32 getAnimationSpeed() const;
+		virtual f32 getAnimationSpeed() const _IRR_OVERRIDE_;
 
 		//! returns the material based on the zero based index i. To get the amount
 		//! of materials used by this scene node, use getMaterialCount().
 		//! This function is needed for inserting the node into the scene hirachy on a
 		//! optimal position for minimizing renderstate changes, but can also be used
 		//! to directly modify the material of a scene node.
-		virtual video::SMaterial& getMaterial(u32 i);
+		virtual video::SMaterial& getMaterial(u32 i) _IRR_OVERRIDE_;
 
 		//! returns amount of materials used by this scene node.
-		virtual u32 getMaterialCount() const;
+		virtual u32 getMaterialCount() const _IRR_OVERRIDE_;
 
 		//! Creates shadow volume scene node as child of this node
 		//! and returns a pointer to it.
@@ -83,57 +83,51 @@ namespace scene
 
 		//! Returns a pointer to a child node, which has the same transformation as
 		//! the corrsesponding joint, if the mesh in this scene node is a skinned mesh.
-		virtual IBoneSceneNode* getJointNode(const c8* jointName);
+		virtual IBoneSceneNode* getJointNode(const c8* jointName) _IRR_OVERRIDE_;
 
 		//! same as getJointNode(const c8* jointName), but based on id
-		virtual IBoneSceneNode* getJointNode(u32 jointID);
+		virtual IBoneSceneNode* getJointNode(u32 jointID) _IRR_OVERRIDE_;
 
 		//! Gets joint count.
-		virtual u32 getJointCount() const;
-
-		//! Deprecated command, please use getJointNode.
-		virtual ISceneNode* getMS3DJointNode(const c8* jointName);
-
-		//! Deprecated command, please use getJointNode.
-		virtual ISceneNode* getXJointNode(const c8* jointName);
+		virtual u32 getJointCount() const _IRR_OVERRIDE_;
 
 		//! Removes a child from this scene node.
 		//! Implemented here, to be able to remove the shadow properly, if there is one,
 		//! or to remove attached childs.
-		virtual bool removeChild(ISceneNode* child);
+		virtual bool removeChild(ISceneNode* child) _IRR_OVERRIDE_;
 
 		//! Starts a MD2 animation.
-		virtual bool setMD2Animation(EMD2_ANIMATION_TYPE anim);
+		virtual bool setMD2Animation(EMD2_ANIMATION_TYPE anim) _IRR_OVERRIDE_;
 
 		//! Starts a special MD2 animation.
-		virtual bool setMD2Animation(const c8* animationName);
+		virtual bool setMD2Animation(const c8* animationName) _IRR_OVERRIDE_;
 
 		//! Returns the current displayed frame number.
-		virtual f32 getFrameNr() const;
+		virtual f32 getFrameNr() const _IRR_OVERRIDE_;
 		//! Returns the current start frame number.
-		virtual s32 getStartFrame() const;
+		virtual s32 getStartFrame() const _IRR_OVERRIDE_;
 		//! Returns the current end frame number.
-		virtual s32 getEndFrame() const;
+		virtual s32 getEndFrame() const _IRR_OVERRIDE_;
 
 		//! Sets if the scene node should not copy the materials of the mesh but use them in a read only style.
 		/* In this way it is possible to change the materials a mesh causing all mesh scene nodes
 		referencing this mesh to change too. */
-		virtual void setReadOnlyMaterials(bool readonly);
+		virtual void setReadOnlyMaterials(bool readonly) _IRR_OVERRIDE_;
 
 		//! Returns if the scene node should not copy the materials of the mesh but use them in a read only style
-		virtual bool isReadOnlyMaterials() const;
+		virtual bool isReadOnlyMaterials() const _IRR_OVERRIDE_;
 
 		//! Sets a new mesh
-		virtual void setMesh(IAnimatedMesh* mesh);
+		virtual void setMesh(IAnimatedMesh* mesh) _IRR_OVERRIDE_;
 
 		//! Returns the current mesh
 		virtual IAnimatedMesh* getMesh(void) _IRR_OVERRIDE_ { return Mesh; }
 
 		//! Writes attributes of the scene node.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the scene node.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 		//! Returns type of the scene node
 		virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_ANIMATED_MESH; }
@@ -143,27 +137,27 @@ namespace scene
 		const SMD3QuaternionTag* getMD3TagTransformation( const core::stringc & tagname);
 
 		//! updates the absolute position based on the relative and the parents position
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 
 		//! Set the joint update mode (0-unused, 1-get joints only, 2-set joints only, 3-move and set)
-		virtual void setJointMode(E_JOINT_UPDATE_ON_RENDER mode);
+		virtual void setJointMode(E_JOINT_UPDATE_ON_RENDER mode) _IRR_OVERRIDE_;
 
 		//! Sets the transition time in seconds (note: This needs to enable joints, and setJointmode maybe set to 2)
 		//! you must call animateJoints(), or the mesh will not animate
-		virtual void setTransitionTime(f32 Time);
+		virtual void setTransitionTime(f32 Time) _IRR_OVERRIDE_;
 
 		//! updates the joint positions of this mesh
-		virtual void animateJoints(bool CalculateAbsolutePositions=true);
+		virtual void animateJoints(bool CalculateAbsolutePositions=true) _IRR_OVERRIDE_;
 
 		//! render mesh ignoring its transformation. Used with ragdolls. (culling is unaffected)
-		virtual void setRenderFromIdentity( bool On );
+		virtual void setRenderFromIdentity( bool On ) _IRR_OVERRIDE_;
 
 		//! Creates a clone of this scene node and its children.
 		/** \param newParent An optional new parent.
 		\param newManager An optional new scene manager.
 		\return The newly created clone of this node. */
-		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CB3DMeshFileLoader.h

@@ -32,13 +32,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".bsp")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! creates/loads an animated mesh from the file.
 	//! \return Pointer to the created mesh. Returns 0 if loading failed.
 	//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
 	//! See IReferenceCounted::drop() for more information.
-	virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+	virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CBSPMeshFileLoader.h

@@ -29,13 +29,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".bsp")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! creates/loads an animated mesh from the file.
 	//! \return Pointer to the created mesh. Returns 0 if loading failed.
 	//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
 	//! See IReferenceCounted::drop() for more information.
-	virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+	virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CBillboardSceneNode.h

@@ -26,34 +26,34 @@ public:
 		video::SColor colorBottom=video::SColor(0xFFFFFFFF));
 
 	//! pre render event
-	virtual void OnRegisterSceneNode();
+	virtual void OnRegisterSceneNode() _IRR_OVERRIDE_;
 
 	//! render
-	virtual void render();
+	virtual void render() _IRR_OVERRIDE_;
 
 	//! returns the axis aligned bounding box of this node
-	virtual const core::aabbox3d<f32>& getBoundingBox() const;
+	virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 	//! sets the size of the billboard
-	virtual void setSize(const core::dimension2d<f32>& size);
+	virtual void setSize(const core::dimension2d<f32>& size) _IRR_OVERRIDE_;
 
 	//! Sets the widths of the top and bottom edges of the billboard independently.
-	virtual void setSize(f32 height, f32 bottomEdgeWidth, f32 topEdgeWidth);
+	virtual void setSize(f32 height, f32 bottomEdgeWidth, f32 topEdgeWidth) _IRR_OVERRIDE_;
 
 	//! gets the size of the billboard
-	virtual const core::dimension2d<f32>& getSize() const;
+	virtual const core::dimension2d<f32>& getSize() const _IRR_OVERRIDE_;
 
 	//! Gets the widths of the top and bottom edges of the billboard.
-	virtual void getSize(f32& height, f32& bottomEdgeWidth, f32& topEdgeWidth) const;
+	virtual void getSize(f32& height, f32& bottomEdgeWidth, f32& topEdgeWidth) const _IRR_OVERRIDE_;
 
-	virtual video::SMaterial& getMaterial(u32 i);
+	virtual video::SMaterial& getMaterial(u32 i) _IRR_OVERRIDE_;
 
 	//! returns amount of materials used by this scene node.
-	virtual u32 getMaterialCount() const;
+	virtual u32 getMaterialCount() const _IRR_OVERRIDE_;
 
 	//! Set the color of all vertices of the billboard
 	//! \param overallColor: the color to set
-	virtual void setColor(const video::SColor& overallColor);
+	virtual void setColor(const video::SColor& overallColor) _IRR_OVERRIDE_;
 
 	//! Set the color of the top and bottom vertices of the billboard
 	//! \param topColor: the color to set the top vertices
@@ -68,16 +68,16 @@ public:
 			video::SColor& bottomColor) const;
 
 	//! Writes attributes of the scene node.
-	virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+	virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 	//! Reads attributes of the scene node.
-	virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+	virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 	//! Returns type of the scene node
 	virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_BILLBOARD; }
 
 	//! Creates a clone of this scene node and its children.
-	virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+	virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CBoneSceneNode.h

@@ -23,31 +23,31 @@ namespace scene
 			s32 id=-1, u32 boneIndex=0, const c8* boneName=0);
 
 		//! Returns the index of the bone
-		virtual u32 getBoneIndex() const;
+		virtual u32 getBoneIndex() const _IRR_OVERRIDE_;
 
 		//! Sets the animation mode of the bone. Returns true if successful.
-		virtual bool setAnimationMode(E_BONE_ANIMATION_MODE mode);
+		virtual bool setAnimationMode(E_BONE_ANIMATION_MODE mode) _IRR_OVERRIDE_;
 
 		//! Gets the current animation mode of the bone
-		virtual E_BONE_ANIMATION_MODE getAnimationMode() const;
+		virtual E_BONE_ANIMATION_MODE getAnimationMode() const _IRR_OVERRIDE_;
 
 		//! returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		/*
 		//! Returns the relative transformation of the scene node.
-		//virtual core::matrix4 getRelativeTransformation() const;
+		//virtual core::matrix4 getRelativeTransformation() const _IRR_OVERRIDE_;
 		*/
 
-		virtual void OnAnimate(u32 timeMs);
+		virtual void OnAnimate(u32 timeMs) _IRR_OVERRIDE_;
 
-		virtual void updateAbsolutePositionOfAllChildren();
+		virtual void updateAbsolutePositionOfAllChildren() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the scene node.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the scene node.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 		//! How the relative transformation of the bone is used
 		virtual void setSkinningSpace( E_BONE_SKINNING_SPACE space )

source/Irrlicht/CCSMLoader.h

@@ -59,10 +59,10 @@ namespace scene
 
 		//! returns true if the file maybe is able to be loaded by this class
 		//! based on the file extension (e.g. ".bsp")
-		virtual bool isALoadableFileExtension(const io::path& filename) const;
+		virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 		//! creates/loads an animated mesh from the file.
-		virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+		virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CCameraSceneNode.h

@@ -30,123 +30,123 @@ namespace scene
 		\param projection The new projection matrix of the camera.
 		\param isOrthogonal Set this to true if the matrix is an orthogonal one (e.g.
 		from matrix4::buildProjectionMatrixOrthoLH(). */
-		virtual void setProjectionMatrix(const core::matrix4& projection, bool isOrthogonal = false);
+		virtual void setProjectionMatrix(const core::matrix4& projection, bool isOrthogonal = false) _IRR_OVERRIDE_;
 
 		//! Gets the current projection matrix of the camera
 		//! \return Returns the current projection matrix of the camera.
-		virtual const core::matrix4& getProjectionMatrix() const;
+		virtual const core::matrix4& getProjectionMatrix() const _IRR_OVERRIDE_;
 
 		//! Gets the current view matrix of the camera
 		//! \return Returns the current view matrix of the camera.
-		virtual const core::matrix4& getViewMatrix() const;
+		virtual const core::matrix4& getViewMatrix() const _IRR_OVERRIDE_;
 
 		//! Sets a custom view matrix affector.
 		/** \param affector: The affector matrix. */
-		virtual void setViewMatrixAffector(const core::matrix4& affector);
+		virtual void setViewMatrixAffector(const core::matrix4& affector) _IRR_OVERRIDE_;
 
 		//! Gets the custom view matrix affector.
-		virtual const core::matrix4& getViewMatrixAffector() const;
+		virtual const core::matrix4& getViewMatrixAffector() const _IRR_OVERRIDE_;
 
 		//! It is possible to send mouse and key events to the camera. Most cameras
 		//! may ignore this input, but camera scene nodes which are created for
 		//! example with scene::ISceneManager::addMayaCameraSceneNode or
 		//! scene::ISceneManager::addMeshViewerCameraSceneNode, may want to get this input
 		//! for changing their position, look at target or whatever.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! Sets the look at target of the camera
 		/** If the camera's target and rotation are bound ( @see bindTargetAndRotation() )
 		then calling this will also change the camera's scene node rotation to match the target.
 		\param pos: Look at target of the camera. */
-		virtual void setTarget(const core::vector3df& pos);
+		virtual void setTarget(const core::vector3df& pos) _IRR_OVERRIDE_;
 
 		//! Sets the rotation of the node.
 		/** This only modifies the relative rotation of the node.
 		If the camera's target and rotation are bound ( @see bindTargetAndRotation() )
 		then calling this will also change the camera's target to match the rotation.
 		\param rotation New rotation of the node in degrees. */
-		virtual void setRotation(const core::vector3df& rotation);
+		virtual void setRotation(const core::vector3df& rotation) _IRR_OVERRIDE_;
 
 		//! Gets the current look at target of the camera
 		/** \return The current look at target of the camera */
-		virtual const core::vector3df& getTarget() const;
+		virtual const core::vector3df& getTarget() const _IRR_OVERRIDE_;
 
 		//! Sets the up vector of the camera.
 		//! \param pos: New upvector of the camera.
-		virtual void setUpVector(const core::vector3df& pos);
+		virtual void setUpVector(const core::vector3df& pos) _IRR_OVERRIDE_;
 
 		//! Gets the up vector of the camera.
 		//! \return Returns the up vector of the camera.
-		virtual const core::vector3df& getUpVector() const;
+		virtual const core::vector3df& getUpVector() const _IRR_OVERRIDE_;
 
 		//! Gets distance from the camera to the near plane.
 		//! \return Value of the near plane of the camera.
-		virtual f32 getNearValue() const;
+		virtual f32 getNearValue() const _IRR_OVERRIDE_;
 
 		//! Gets the distance from the camera to the far plane.
 		//! \return Value of the far plane of the camera.
-		virtual f32 getFarValue() const;
+		virtual f32 getFarValue() const _IRR_OVERRIDE_;
 
 		//! Get the aspect ratio of the camera.
 		//! \return The aspect ratio of the camera.
-		virtual f32 getAspectRatio() const;
+		virtual f32 getAspectRatio() const _IRR_OVERRIDE_;
 
 		//! Gets the field of view of the camera.
 		//! \return Field of view of the camera
-		virtual f32 getFOV() const;
+		virtual f32 getFOV() const _IRR_OVERRIDE_;
 
 		//! Sets the value of the near clipping plane. (default: 1.0f)
-		virtual void setNearValue(f32 zn);
+		virtual void setNearValue(f32 zn) _IRR_OVERRIDE_;
 
 		//! Sets the value of the far clipping plane (default: 2000.0f)
-		virtual void setFarValue(f32 zf);
+		virtual void setFarValue(f32 zf) _IRR_OVERRIDE_;
 
 		//! Sets the aspect ratio (default: 4.0f / 3.0f)
-		virtual void setAspectRatio(f32 aspect);
+		virtual void setAspectRatio(f32 aspect) _IRR_OVERRIDE_;
 
 		//! Sets the field of view (Default: PI / 3.5f)
-		virtual void setFOV(f32 fovy);
+		virtual void setFOV(f32 fovy) _IRR_OVERRIDE_;
 
 		//! PreRender event
-		virtual void OnRegisterSceneNode();
+		virtual void OnRegisterSceneNode() _IRR_OVERRIDE_;
 
 		//! Render
-		virtual void render();
+		virtual void render() _IRR_OVERRIDE_;
 
 		//! Update
-		virtual void updateMatrices();
+		virtual void updateMatrices() _IRR_OVERRIDE_;
 
 		//! Returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! Returns the view area. Sometimes needed by bsp or lod render nodes.
-		virtual const SViewFrustum* getViewFrustum() const;
+		virtual const SViewFrustum* getViewFrustum() const _IRR_OVERRIDE_;
 
 		//! Disables or enables the camera to get key or mouse inputs.
 		//! If this is set to true, the camera will respond to key inputs
 		//! otherwise not.
-		virtual void setInputReceiverEnabled(bool enabled);
+		virtual void setInputReceiverEnabled(bool enabled) _IRR_OVERRIDE_;
 
 		//! Returns if the input receiver of the camera is currently enabled.
-		virtual bool isInputReceiverEnabled() const;
+		virtual bool isInputReceiverEnabled() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the scene node.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the scene node.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 		//! Returns type of the scene node
 		virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_CAMERA; }
 
 		//! Binds the camera scene node's rotation to its target position and vice vera, or unbinds them.
-		virtual void bindTargetAndRotation(bool bound);
+		virtual void bindTargetAndRotation(bool bound) _IRR_OVERRIDE_;
 
 		//! Queries if the camera scene node's rotation and its target position are bound together.
-		virtual bool getTargetAndRotationBinding(void) const;
+		virtual bool getTargetAndRotationBinding(void) const _IRR_OVERRIDE_;
 
 		//! Creates a clone of this scene node and its children.
-		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 	protected:
 

source/Irrlicht/CCgMaterialRenderer.h

@@ -38,7 +38,7 @@ public:
 	CGenum getSpace() const;
 	CGtype getType() const;
 
-	virtual void update(const void* data, const SMaterial& material) const = 0;
+	virtual void update(const void* data, const SMaterial& material) const = 0 _IRR_OVERRIDE_;
 
 protected:
 	core::stringc Name;
@@ -133,22 +133,22 @@ public:
 	CCgMaterialRenderer(IShaderConstantSetCallBack* callback = 0, IMaterialRenderer* baseMaterial = 0, s32 userData = 0);
 	virtual ~CCgMaterialRenderer();
 
-	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services) = 0;
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) = 0;
-	virtual void OnUnsetMaterial() = 0;
-
-	virtual bool isTransparent() const;
-
-	virtual void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates) = 0;
-	virtual s32 getVertexShaderConstantID(const c8* name);
-	virtual s32 getPixelShaderConstantID(const c8* name);
-	virtual void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1);
-	virtual void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1);
-	virtual bool setVertexShaderConstant(s32 index, const f32* floats, int count);
-	virtual bool setVertexShaderConstant(s32 index, const s32* ints, int count);
-	virtual bool setPixelShaderConstant(s32 index, const f32* floats, int count);
-	virtual bool setPixelShaderConstant(s32 index, const s32* ints, int count);
-	virtual IVideoDriver* getVideoDriver() = 0;
+	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services) = 0 _IRR_OVERRIDE_;
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) = 0 _IRR_OVERRIDE_;
+	virtual void OnUnsetMaterial() = 0 _IRR_OVERRIDE_;
+
+	virtual bool isTransparent() const _IRR_OVERRIDE_;
+
+	virtual void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates) = 0 _IRR_OVERRIDE_;
+	virtual s32 getVertexShaderConstantID(const c8* name) _IRR_OVERRIDE_;
+	virtual s32 getPixelShaderConstantID(const c8* name) _IRR_OVERRIDE_;
+	virtual void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) _IRR_OVERRIDE_;
+	virtual void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) _IRR_OVERRIDE_;
+	virtual bool setVertexShaderConstant(s32 index, const f32* floats, int count) _IRR_OVERRIDE_;
+	virtual bool setVertexShaderConstant(s32 index, const s32* ints, int count) _IRR_OVERRIDE_;
+	virtual bool setPixelShaderConstant(s32 index, const f32* floats, int count) _IRR_OVERRIDE_;
+	virtual bool setPixelShaderConstant(s32 index, const s32* ints, int count) _IRR_OVERRIDE_;
+	virtual IVideoDriver* getVideoDriver() = 0 _IRR_OVERRIDE_;
 
 protected:
 	void getUniformList();

source/Irrlicht/CColladaFileLoader.h

@@ -187,13 +187,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".cob")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! creates/loads an animated mesh from the file.
 	//! \return Pointer to the created mesh. Returns 0 if loading failed.
 	//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
 	//! See IReferenceCounted::drop() for more information.
-	virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+	virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CColladaMeshWriter.h

@@ -26,46 +26,46 @@ namespace scene
 	{
 	public:
 		//! Which lighting model should be used in the technique (FX) section when exporting effects (materials)
-		virtual irr::scene::E_COLLADA_TECHNIQUE_FX getTechniqueFx(const irr::video::SMaterial& material) const;
+		virtual irr::scene::E_COLLADA_TECHNIQUE_FX getTechniqueFx(const irr::video::SMaterial& material) const _IRR_OVERRIDE_;
 
 		//! Which texture index should be used when writing the texture of the given sampler color.
-		virtual irr::s32 getTextureIdx(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
+		virtual irr::s32 getTextureIdx(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const _IRR_OVERRIDE_;
 
 		//! Return which color from Irrlicht should be used for the color requested by collada
-		virtual irr::scene::E_COLLADA_IRR_COLOR getColorMapping(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
+		virtual irr::scene::E_COLLADA_IRR_COLOR getColorMapping(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const _IRR_OVERRIDE_;
 
 		//! Return custom colors for certain color types requested by collada.
-		virtual irr::video::SColor getCustomColor(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
+		virtual irr::video::SColor getCustomColor(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const _IRR_OVERRIDE_;
 
 		//! Return the settings for transparence
-		virtual irr::scene::E_COLLADA_TRANSPARENT_FX getTransparentFx(const irr::video::SMaterial& material) const;
+		virtual irr::scene::E_COLLADA_TRANSPARENT_FX getTransparentFx(const irr::video::SMaterial& material) const _IRR_OVERRIDE_;
 
 		//! Transparency value for that material.
-		virtual irr::f32 getTransparency(const irr::video::SMaterial& material) const;
+		virtual irr::f32 getTransparency(const irr::video::SMaterial& material) const _IRR_OVERRIDE_;
 
 		//! Reflectivity value for that material
-		virtual irr::f32 getReflectivity(const irr::video::SMaterial& material) const;
+		virtual irr::f32 getReflectivity(const irr::video::SMaterial& material) const _IRR_OVERRIDE_;
 
 		//! Return index of refraction for that material
-		virtual irr::f32 getIndexOfRefraction(const irr::video::SMaterial& material) const;
+		virtual irr::f32 getIndexOfRefraction(const irr::video::SMaterial& material) const _IRR_OVERRIDE_;
 
 		//! Should node be used in scene export? By default all visible nodes are exported.
-		virtual bool isExportable(const irr::scene::ISceneNode * node) const;
+		virtual bool isExportable(const irr::scene::ISceneNode * node) const _IRR_OVERRIDE_;
 
 		//! Return the mesh for the given nod. If it has no mesh or shouldn't export it's mesh return 0.
-		virtual irr::scene::IMesh* getMesh(irr::scene::ISceneNode * node);
+		virtual irr::scene::IMesh* getMesh(irr::scene::ISceneNode * node) _IRR_OVERRIDE_;
 
 		//! Return if the node has it's own material overwriting the mesh-materials
-		virtual bool useNodeMaterial(const scene::ISceneNode* node) const;
+		virtual bool useNodeMaterial(const scene::ISceneNode* node) const _IRR_OVERRIDE_;
 	};
 
 	class CColladaMeshWriterNames  : public virtual IColladaMeshWriterNames
 	{
 	public:
 		CColladaMeshWriterNames(IColladaMeshWriter * writer);
-		virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh, int instance);
-		virtual irr::core::stringw nameForNode(const scene::ISceneNode* node);
-		virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node);
+		virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh, int instance) _IRR_OVERRIDE_;
+		virtual irr::core::stringw nameForNode(const scene::ISceneNode* node) _IRR_OVERRIDE_;
+		virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) _IRR_OVERRIDE_;
 	protected:
 		irr::core::stringw nameForPtr(const void* ptr) const;
 	private:
@@ -85,19 +85,19 @@ public:
 	virtual ~CColladaMeshWriter();
 
 	//! Returns the type of the mesh writer
-	virtual EMESH_WRITER_TYPE getType() const;
+	virtual EMESH_WRITER_TYPE getType() const _IRR_OVERRIDE_;
 
 	//! writes a scene starting with the given node
-	virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root);
+	virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root) _IRR_OVERRIDE_;
 
 	//! writes a mesh
-	virtual bool writeMesh(io::IWriteFile* file, scene::IMesh* mesh, s32 flags=EMWF_NONE);
+	virtual bool writeMesh(io::IWriteFile* file, scene::IMesh* mesh, s32 flags=EMWF_NONE) _IRR_OVERRIDE_;
 
 	// Restrict the characters of oldString a set of allowed characters in xs::NCName and add the prefix.
-	virtual irr::core::stringw toNCName(const irr::core::stringw& oldString, const irr::core::stringw& prefix=irr::core::stringw(L"_NC_")) const;
+	virtual irr::core::stringw toNCName(const irr::core::stringw& oldString, const irr::core::stringw& prefix=irr::core::stringw(L"_NC_")) const _IRR_OVERRIDE_;
 
 	//! After export you can find out which name had been used for writing the geometry for this node.
-	virtual const irr::core::stringw* findGeometryNameForNode(ISceneNode* node);
+	virtual const irr::core::stringw* findGeometryNameForNode(ISceneNode* node) _IRR_OVERRIDE_;
 
 protected:
 

source/Irrlicht/CCubeSceneNode.h

@@ -24,23 +24,23 @@ namespace scene
 
 		virtual ~CCubeSceneNode();
 
-		virtual void OnRegisterSceneNode();
+		virtual void OnRegisterSceneNode() _IRR_OVERRIDE_;
 
 		//! renders the node.
-		virtual void render();
+		virtual void render() _IRR_OVERRIDE_;
 
 		//! returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! returns the material based on the zero based index i. To get the amount
 		//! of materials used by this scene node, use getMaterialCount().
 		//! This function is needed for inserting the node into the scene hirachy on a
 		//! optimal position for minimizing renderstate changes, but can also be used
 		//! to directly modify the material of a scene node.
-		virtual video::SMaterial& getMaterial(u32 i);
+		virtual video::SMaterial& getMaterial(u32 i) _IRR_OVERRIDE_;
 
 		//! returns amount of materials used by this scene node.
-		virtual u32 getMaterialCount() const;
+		virtual u32 getMaterialCount() const _IRR_OVERRIDE_;
 
 		//! Returns type of the scene node
 		virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_CUBE; }
@@ -51,13 +51,13 @@ namespace scene
 			s32 id, bool zfailmethod=true, f32 infinity=10000.0f);
 
 		//! Writes attributes of the scene node.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the scene node.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 		//! Creates a clone of this scene node and its children.
-		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 		//! Sets a new mesh to display
 		virtual void setMesh(IMesh* mesh) _IRR_OVERRIDE_ {}
@@ -76,7 +76,7 @@ namespace scene
 		//! Removes a child from this scene node.
 		//! Implemented here, to be able to remove the shadow properly, if there is one,
 		//! or to remove attached childs.
-		virtual bool removeChild(ISceneNode* child);
+		virtual bool removeChild(ISceneNode* child) _IRR_OVERRIDE_;
 
 	private:
 		void setSize();

source/Irrlicht/CD3D8NormalMapRenderer.h

@@ -31,12 +31,12 @@ public:
 
 	//! Called by the engine when the vertex and/or pixel shader constants for an
 	//! material renderer should be set.
-	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) _IRR_OVERRIDE_;
 
 	bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
 
 	//! Returns the render capability of the material.
-	virtual s32 getRenderCapability() const;
+	virtual s32 getRenderCapability() const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CD3D8ParallaxMapRenderer.h

@@ -31,9 +31,9 @@ public:
 
 	//! Called by the engine when the vertex and/or pixel shader constants for an
 	//! material renderer should be set.
-	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) _IRR_OVERRIDE_;
 
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
 
 	virtual void OnSetMaterial(const SMaterial& material) _IRR_OVERRIDE_ { }
 	virtual void OnSetMaterial(const video::SMaterial& material,
@@ -41,7 +41,7 @@ public:
 		bool resetAllRenderstates, video::IMaterialRendererServices* services);
 
 	//! Returns the render capability of the material.
-	virtual s32 getRenderCapability() const;
+	virtual s32 getRenderCapability() const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CD3D8ShaderMaterialRenderer.h

@@ -40,12 +40,12 @@ public:
 	virtual void OnSetMaterial(const video::SMaterial& material, const video::SMaterial& lastMaterial,
 		bool resetAllRenderstates, video::IMaterialRendererServices* services);
 
-	virtual void OnUnsetMaterial();
+	virtual void OnUnsetMaterial() _IRR_OVERRIDE_;
 
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
 
 	//! Returns if the material is transparent.
-	virtual bool isTransparent() const;
+	virtual bool isTransparent() const _IRR_OVERRIDE_;
 
 protected:
 

source/Irrlicht/CD3D8Texture.h

@@ -38,25 +38,25 @@ public:
 	virtual ~CD3D8Texture();
 
 	//! lock function
-	virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0);
+	virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0) _IRR_OVERRIDE_;
 
 	//! unlock function
-	virtual void unlock();
+	virtual void unlock() _IRR_OVERRIDE_;
 
 	//! Returns original size of the texture.
-	virtual const core::dimension2d<u32>& getOriginalSize() const;
+	virtual const core::dimension2d<u32>& getOriginalSize() const _IRR_OVERRIDE_;
 
 	//! Returns (=size) of the texture.
-	virtual const core::dimension2d<u32>& getSize() const;
+	virtual const core::dimension2d<u32>& getSize() const _IRR_OVERRIDE_;
 
 	//! returns driver type of texture (=the driver, who created the texture)
-	virtual E_DRIVER_TYPE getDriverType() const;
+	virtual E_DRIVER_TYPE getDriverType() const _IRR_OVERRIDE_;
 
 	//! returns color format of texture
-	virtual ECOLOR_FORMAT getColorFormat() const;
+	virtual ECOLOR_FORMAT getColorFormat() const _IRR_OVERRIDE_;
 
 	//! returns pitch of texture (in bytes)
-	virtual u32 getPitch() const;
+	virtual u32 getPitch() const _IRR_OVERRIDE_;
 
 	//! returns the DIRECT3D8 Texture
 	IDirect3DTexture8* getDX8Texture() const;
@@ -66,10 +66,10 @@ public:
 
 	//! Regenerates the mip map levels of the texture. Useful after locking and
 	//! modifying the texture
-	virtual void regenerateMipMapLevels(void* mipmapData=0);
+	virtual void regenerateMipMapLevels(void* mipmapData=0) _IRR_OVERRIDE_;
 
 	//! returns if it is a render target
-	virtual bool isRenderTarget() const;
+	virtual bool isRenderTarget() const _IRR_OVERRIDE_;
 
 	//! Returns pointer to the render target surface
 	IDirect3DSurface8* getRenderTargetSurface();

source/Irrlicht/CD3D9CgMaterialRenderer.h

@@ -53,12 +53,12 @@ public:
 
 	virtual ~CD3D9CgMaterialRenderer();
 
-	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services);
-	virtual bool OnRender(IMaterialRendererServices* services, E_VERTEX_TYPE vtxtype);
-	virtual void OnUnsetMaterial();
+	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates, IMaterialRendererServices* services) _IRR_OVERRIDE_;
+	virtual bool OnRender(IMaterialRendererServices* services, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
+	virtual void OnUnsetMaterial() _IRR_OVERRIDE_;
 
-	virtual void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates);
-	virtual IVideoDriver* getVideoDriver();
+	virtual void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates) _IRR_OVERRIDE_;
+	virtual IVideoDriver* getVideoDriver() _IRR_OVERRIDE_;
 
 protected:
 	void init(s32& materialType,

source/Irrlicht/CD3D9NormalMapRenderer.h

@@ -36,12 +36,12 @@ public:
 
 	//! Called by the engine when the vertex and/or pixel shader constants for an
 	//! material renderer should be set.
-	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) _IRR_OVERRIDE_;
 
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
 
 	//! Returns the render capability of the material.
-	virtual s32 getRenderCapability() const;
+	virtual s32 getRenderCapability() const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CD3D9ParallaxMapRenderer.h

@@ -36,12 +36,12 @@ public:
 
 	//! Called by the engine when the vertex and/or pixel shader constants for an
 	//! material renderer should be set.
-	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) _IRR_OVERRIDE_;
 
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
 
 	//! Returns the render capability of the material.
-	virtual s32 getRenderCapability() const;
+	virtual s32 getRenderCapability() const _IRR_OVERRIDE_;
 
 	virtual void OnSetMaterial(const SMaterial& material) _IRR_OVERRIDE_ { }
 	virtual void OnSetMaterial(const video::SMaterial& material,

source/Irrlicht/CD3D9ShaderMaterialRenderer.h

@@ -41,12 +41,12 @@ public:
 	virtual void OnSetMaterial(const video::SMaterial& material, const video::SMaterial& lastMaterial,
 		bool resetAllRenderstates, video::IMaterialRendererServices* services);
 
-	virtual void OnUnsetMaterial();
+	virtual void OnUnsetMaterial() _IRR_OVERRIDE_;
 
-	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) _IRR_OVERRIDE_;
 
 	//! Returns if the material is transparent.
-	virtual bool isTransparent() const;
+	virtual bool isTransparent() const _IRR_OVERRIDE_;
 
 protected:
 

source/Irrlicht/CD3D9Texture.h

@@ -42,25 +42,25 @@ public:
 	virtual ~CD3D9Texture();
 
 	//! lock function
-	virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0);
+	virtual void* lock(E_TEXTURE_LOCK_MODE mode=ETLM_READ_WRITE, u32 mipmapLevel=0) _IRR_OVERRIDE_;
 
 	//! unlock function
-	virtual void unlock();
+	virtual void unlock() _IRR_OVERRIDE_;
 
 	//! Returns original size of the texture.
-	virtual const core::dimension2d<u32>& getOriginalSize() const;
+	virtual const core::dimension2d<u32>& getOriginalSize() const _IRR_OVERRIDE_;
 
 	//! Returns (=size) of the texture.
-	virtual const core::dimension2d<u32>& getSize() const;
+	virtual const core::dimension2d<u32>& getSize() const _IRR_OVERRIDE_;
 
 	//! returns driver type of texture (=the driver, who created the texture)
-	virtual E_DRIVER_TYPE getDriverType() const;
+	virtual E_DRIVER_TYPE getDriverType() const _IRR_OVERRIDE_;
 
 	//! returns color format of texture
-	virtual ECOLOR_FORMAT getColorFormat() const;
+	virtual ECOLOR_FORMAT getColorFormat() const _IRR_OVERRIDE_;
 
 	//! returns pitch of texture (in bytes)
-	virtual u32 getPitch() const;
+	virtual u32 getPitch() const _IRR_OVERRIDE_;
 
 	//! returns the DIRECT3D9 Texture
 	IDirect3DBaseTexture9* getDX9Texture() const;
@@ -70,10 +70,10 @@ public:
 
 	//! Regenerates the mip map levels of the texture. Useful after locking and
 	//! modifying the texture
-	virtual void regenerateMipMapLevels(void* mipmapData=0);
+	virtual void regenerateMipMapLevels(void* mipmapData=0) _IRR_OVERRIDE_;
 
 	//! returns if it is a render target
-	virtual bool isRenderTarget() const;
+	virtual bool isRenderTarget() const _IRR_OVERRIDE_;
 
 	//! Returns pointer to the render target surface
 	IDirect3DSurface9* getRenderTargetSurface();

source/Irrlicht/CDMFLoader.h

@@ -52,13 +52,13 @@ namespace scene
 
 		//! returns true if the file maybe is able to be loaded by this class
 		//! based on the file extension (e.g. ".cob")
-		virtual bool isALoadableFileExtension(const io::path& filename) const;
+		virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 		/** creates/loads an animated mesh from the file.
 		\return Pointer to the created mesh. Returns 0 if loading failed.
 		If you no longer need the mesh, you should call IAnimatedMesh::drop().
 		See IReferenceCounted::drop() for more information.*/
-		virtual IAnimatedMesh* createMesh(io::IReadFile* file);
+		virtual IAnimatedMesh* createMesh(io::IReadFile* file) _IRR_OVERRIDE_;
 
 		/** loads dynamic lights present in this scene.
 		Note that loaded lights from DeleD must have the suffix \b dynamic_ and must be \b pointlight.

source/Irrlicht/CDefaultGUIElementFactory.h

@@ -28,31 +28,31 @@ namespace gui
 		/** \param type: Type of the element to add.
 		\param parent: Parent scene node of the new element. A value of 0 adds it to the root.
 		\return Returns pointer to the new element or 0 if unsuccessful. */
-		virtual IGUIElement* addGUIElement(EGUI_ELEMENT_TYPE type, IGUIElement* parent=0);
+		virtual IGUIElement* addGUIElement(EGUI_ELEMENT_TYPE type, IGUIElement* parent=0) _IRR_OVERRIDE_;
 
 		//! Adds a GUI element to the GUI Environment based on its type name.
 		/** \param typeName: Type name of the element to add. Taken from the GUIElementTypeNames c8* array.
 		\param parent: Parent scene node of the new element. A value of 0 adds it to the root.
 		\return Returns pointer to the new element or 0 if unsuccessful. */
-		virtual IGUIElement* addGUIElement(const c8* typeName, IGUIElement* parent=0);
+		virtual IGUIElement* addGUIElement(const c8* typeName, IGUIElement* parent=0) _IRR_OVERRIDE_;
 
 		//! Returns the amount of GUI element types this factory is able to create.
-		virtual s32 getCreatableGUIElementTypeCount() const;
+		virtual s32 getCreatableGUIElementTypeCount() const _IRR_OVERRIDE_;
 
 		//! Returns the type of a createable GUI element type based on the index.
 		/** \param idx: Index of the element type in this factory. The value must be equal or greater than 0
 		and lower than getCreatableGUIElementTypeCount(). */
-		virtual EGUI_ELEMENT_TYPE getCreateableGUIElementType(s32 idx) const;
+		virtual EGUI_ELEMENT_TYPE getCreateableGUIElementType(s32 idx) const _IRR_OVERRIDE_;
 
 		//! Returns the type name of a createable GUI element type based on the index.
 		/** \param idx: Index of the element type in this factory. The value must be equal or greater than 0
 		and lower than getCreatableGUIElementTypeCount(). */
-		virtual const c8* getCreateableGUIElementTypeName(s32 idx) const;
+		virtual const c8* getCreateableGUIElementTypeName(s32 idx) const _IRR_OVERRIDE_;
 
 		//! Returns the type name of a createable GUI element based on its type.
 		/** \param type: Type of the GUI element.
 		\return: Returns the name of the type if this factory can create it, otherwise it returns 0. */
-		virtual const c8* getCreateableGUIElementTypeName(EGUI_ELEMENT_TYPE type) const;
+		virtual const c8* getCreateableGUIElementTypeName(EGUI_ELEMENT_TYPE type) const _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CDefaultSceneNodeAnimatorFactory.h

@@ -32,32 +32,32 @@ namespace scene
 		\param target: Target scene node of the new animator.
 		\return Returns pointer to the new scene node animator or null if not successful. You need to
 		drop this pointer after calling this, see IReferenceCounted::drop() for details. */
-		virtual ISceneNodeAnimator* createSceneNodeAnimator(ESCENE_NODE_ANIMATOR_TYPE type, ISceneNode* target);
+		virtual ISceneNodeAnimator* createSceneNodeAnimator(ESCENE_NODE_ANIMATOR_TYPE type, ISceneNode* target) _IRR_OVERRIDE_;
 
 		//! creates a scene node animator based on its type name
 		/** \param typeName: Type of the scene node animator to add.
 		\param target: Target scene node of the new animator.
 		\return Returns pointer to the new scene node animator or null if not successful. You need to
 		drop this pointer after calling this, see IReferenceCounted::drop() for details. */
-		virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target);
+		virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target) _IRR_OVERRIDE_;
 
 		//! returns amount of scene node animator types this factory is able to create
-		virtual u32 getCreatableSceneNodeAnimatorTypeCount() const;
+		virtual u32 getCreatableSceneNodeAnimatorTypeCount() const _IRR_OVERRIDE_;
 
 		//! returns type of a createable scene node animator type
 		/** \param idx: Index of scene node animator type in this factory. Must be a value between 0 and
 		getCreatableSceneNodeTypeCount() */
-		virtual ESCENE_NODE_ANIMATOR_TYPE getCreateableSceneNodeAnimatorType(u32 idx) const;
+		virtual ESCENE_NODE_ANIMATOR_TYPE getCreateableSceneNodeAnimatorType(u32 idx) const _IRR_OVERRIDE_;
 
 		//! returns type name of a createable scene node animator type
 		/** \param idx: Index of scene node animator type in this factory. Must be a value between 0 and
 		getCreatableSceneNodeAnimatorTypeCount() */
-		virtual const c8* getCreateableSceneNodeAnimatorTypeName(u32 idx) const;
+		virtual const c8* getCreateableSceneNodeAnimatorTypeName(u32 idx) const _IRR_OVERRIDE_;
 
 		//! returns type name of a createable scene node animator type
 		/** \param type: Type of scene node animator.
 		\return: Returns name of scene node animator type if this factory can create the type, otherwise 0. */
-		virtual const c8* getCreateableSceneNodeAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) const;
+		virtual const c8* getCreateableSceneNodeAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) const _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CDefaultSceneNodeFactory.h

@@ -27,31 +27,31 @@ namespace scene
 		/** \param type: Type of the scene node to add.
 		\param parent: Parent scene node of the new node, can be null to add the scene node to the root.
 		\return Returns pointer to the new scene node or null if not successful. */
-		virtual ISceneNode* addSceneNode(ESCENE_NODE_TYPE type, ISceneNode* parent=0);
+		virtual ISceneNode* addSceneNode(ESCENE_NODE_TYPE type, ISceneNode* parent=0) _IRR_OVERRIDE_;
 
 		//! adds a scene node to the scene graph based on its type name
 		/** \param typeName: Type name of the scene node to add.
 		\param parent: Parent scene node of the new node, can be null to add the scene node to the root.
 		\return Returns pointer to the new scene node or null if not successful. */
-		virtual ISceneNode* addSceneNode(const c8* typeName, ISceneNode* parent=0);
+		virtual ISceneNode* addSceneNode(const c8* typeName, ISceneNode* parent=0) _IRR_OVERRIDE_;
 
 		//! returns amount of scene node types this factory is able to create
-		virtual u32 getCreatableSceneNodeTypeCount() const;
+		virtual u32 getCreatableSceneNodeTypeCount() const _IRR_OVERRIDE_;
 
 		//! returns type name of a createable scene node type by index
 		/** \param idx: Index of scene node type in this factory. Must be a value between 0 and
 		uetCreatableSceneNodeTypeCount() */
-		virtual const c8* getCreateableSceneNodeTypeName(u32 idx) const;
+		virtual const c8* getCreateableSceneNodeTypeName(u32 idx) const _IRR_OVERRIDE_;
 
 		//! returns type of a createable scene node type
 		/** \param idx: Index of scene node type in this factory. Must be a value between 0 and
 		getCreatableSceneNodeTypeCount() */
-		virtual ESCENE_NODE_TYPE getCreateableSceneNodeType(u32 idx) const;
+		virtual ESCENE_NODE_TYPE getCreateableSceneNodeType(u32 idx) const _IRR_OVERRIDE_;
 
 		//! returns type name of a createable scene node type
 		/** \param idx: Type of scene node.
 		\return: Returns name of scene node type if this factory can create the type, otherwise 0. */
-		virtual const c8* getCreateableSceneNodeTypeName(ESCENE_NODE_TYPE type) const;
+		virtual const c8* getCreateableSceneNodeTypeName(ESCENE_NODE_TYPE type) const _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CDepthBuffer.h

@@ -23,13 +23,13 @@ namespace video
 		virtual ~CDepthBuffer();
 
 		//! clears the zbuffer
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! sets the new size of the zbuffer
-		virtual void setSize(const core::dimension2d<u32>& size);
+		virtual void setSize(const core::dimension2d<u32>& size) _IRR_OVERRIDE_;
 
 		//! returns the size of the zbuffer
-		virtual const core::dimension2d<u32>& getSize() const;
+		virtual const core::dimension2d<u32>& getSize() const _IRR_OVERRIDE_;
 
 		//! locks the zbuffer
 		virtual void* lock() _IRR_OVERRIDE_ { return (void*) Buffer; }
@@ -61,13 +61,13 @@ namespace video
 		virtual ~CStencilBuffer();
 
 		//! clears the zbuffer
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! sets the new size of the zbuffer
-		virtual void setSize(const core::dimension2d<u32>& size);
+		virtual void setSize(const core::dimension2d<u32>& size) _IRR_OVERRIDE_;
 
 		//! returns the size of the zbuffer
-		virtual const core::dimension2d<u32>& getSize() const;
+		virtual const core::dimension2d<u32>& getSize() const _IRR_OVERRIDE_;
 
 		//! locks the zbuffer
 		virtual void* lock() _IRR_OVERRIDE_ { return (void*) Buffer; }

source/Irrlicht/CDummyTransformationSceneNode.h

@@ -20,15 +20,15 @@ namespace scene
 		CDummyTransformationSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id);
 
 		//! returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! Returns a reference to the current relative transformation matrix.
 		//! This is the matrix, this scene node uses instead of scale, translation
 		//! and rotation.
-		virtual core::matrix4& getRelativeTransformationMatrix();
+		virtual core::matrix4& getRelativeTransformationMatrix() _IRR_OVERRIDE_;
 
 		//! Returns the relative transformation of the scene node.
-		virtual core::matrix4 getRelativeTransformation() const;
+		virtual core::matrix4 getRelativeTransformation() const _IRR_OVERRIDE_;
 
 		//! does nothing.
 		virtual void render() _IRR_OVERRIDE_ {}
@@ -37,19 +37,19 @@ namespace scene
 		virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_DUMMY_TRANSFORMATION; }
 
 		//! Creates a clone of this scene node and its children.
-		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 
 	private:
 
 		// TODO: We can add least add some warnings to find troubles faster until we have
 		// fixed bug id 2318691.
-		virtual const core::vector3df& getScale() const;
-		virtual void setScale(const core::vector3df& scale);
-		virtual const core::vector3df& getRotation() const;
-		virtual void setRotation(const core::vector3df& rotation);
-		virtual const core::vector3df& getPosition() const;
-		virtual void setPosition(const core::vector3df& newpos);
+		virtual const core::vector3df& getScale() const _IRR_OVERRIDE_;
+		virtual void setScale(const core::vector3df& scale) _IRR_OVERRIDE_;
+		virtual const core::vector3df& getRotation() const _IRR_OVERRIDE_;
+		virtual void setRotation(const core::vector3df& rotation) _IRR_OVERRIDE_;
+		virtual const core::vector3df& getPosition() const _IRR_OVERRIDE_;
+		virtual void setPosition(const core::vector3df& newpos) _IRR_OVERRIDE_;
 
 		core::matrix4 RelativeTransformationMatrix;
 		core::aabbox3d<f32> Box;

source/Irrlicht/CEmptySceneNode.h

@@ -20,19 +20,19 @@ namespace scene
 		CEmptySceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id);
 
 		//! returns the axis aligned bounding box of this node
-		virtual const core::aabbox3d<f32>& getBoundingBox() const;
+		virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
 
 		//! This method is called just before the rendering process of the whole scene.
-		virtual void OnRegisterSceneNode();
+		virtual void OnRegisterSceneNode() _IRR_OVERRIDE_;
 
 		//! does nothing.
-		virtual void render();
+		virtual void render() _IRR_OVERRIDE_;
 
 		//! Returns type of the scene node
 		virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_EMPTY; }
 
 		//! Creates a clone of this scene node and its children.
-		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0);
+		virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CFileList.h

@@ -82,37 +82,37 @@ public:
 	\param offset The offset where the file is stored in an archive
 	\param size The size of the file in bytes.
 	\param id The ID of the file in the archive which owns it */
-	virtual u32 addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id=0);
+	virtual u32 addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id=0) _IRR_OVERRIDE_;
 
 	//! Sorts the file list. You should call this after adding any items to the file list
-	virtual void sort();
+	virtual void sort() _IRR_OVERRIDE_;
 
 	//! Returns the amount of files in the filelist.
-	virtual u32 getFileCount() const;
+	virtual u32 getFileCount() const _IRR_OVERRIDE_;
 
 	//! Gets the name of a file in the list, based on an index.
-	virtual const io::path& getFileName(u32 index) const;
+	virtual const io::path& getFileName(u32 index) const _IRR_OVERRIDE_;
 
 	//! Gets the full name of a file in the list, path included, based on an index.
-	virtual const io::path& getFullFileName(u32 index) const;
+	virtual const io::path& getFullFileName(u32 index) const _IRR_OVERRIDE_;
 
 	//! Returns the ID of a file in the file list, based on an index.
-	virtual u32 getID(u32 index) const;
+	virtual u32 getID(u32 index) const _IRR_OVERRIDE_;
 
 	//! Returns true if the file is a directory
-	virtual bool isDirectory(u32 index) const;
+	virtual bool isDirectory(u32 index) const _IRR_OVERRIDE_;
 
 	//! Returns the size of a file
-	virtual u32 getFileSize(u32 index) const;
+	virtual u32 getFileSize(u32 index) const _IRR_OVERRIDE_;
 
 	//! Returns the offest of a file
-	virtual u32 getFileOffset(u32 index) const;
+	virtual u32 getFileOffset(u32 index) const _IRR_OVERRIDE_;
 
 	//! Searches for a file or folder within the list, returns the index
-	virtual s32 findFile(const io::path& filename, bool isFolder) const;
+	virtual s32 findFile(const io::path& filename, bool isFolder) const _IRR_OVERRIDE_;
 
 	//! Returns the base path of the file list
-	virtual const io::path& getPath() const;
+	virtual const io::path& getPath() const _IRR_OVERRIDE_;
 
 protected:
 

source/Irrlicht/CFileSystem.h

@@ -31,19 +31,19 @@ public:
 	virtual ~CFileSystem();
 
 	//! opens a file for read access
-	virtual IReadFile* createAndOpenFile(const io::path& filename);
+	virtual IReadFile* createAndOpenFile(const io::path& filename) _IRR_OVERRIDE_;
 
 	//! Creates an IReadFile interface for accessing memory like a file.
-	virtual IReadFile* createMemoryReadFile(const void* memory, s32 len, const io::path& fileName, bool deleteMemoryWhenDropped = false);
+	virtual IReadFile* createMemoryReadFile(const void* memory, s32 len, const io::path& fileName, bool deleteMemoryWhenDropped = false) _IRR_OVERRIDE_;
 
 	//! Creates an IReadFile interface for accessing files inside files
-	virtual IReadFile* createLimitReadFile(const io::path& fileName, IReadFile* alreadyOpenedFile, long pos, long areaSize);
+	virtual IReadFile* createLimitReadFile(const io::path& fileName, IReadFile* alreadyOpenedFile, long pos, long areaSize) _IRR_OVERRIDE_;
 
 	//! Creates an IWriteFile interface for accessing memory like a file.
-	virtual IWriteFile* createMemoryWriteFile(void* memory, s32 len, const io::path& fileName, bool deleteMemoryWhenDropped=false);
+	virtual IWriteFile* createMemoryWriteFile(void* memory, s32 len, const io::path& fileName, bool deleteMemoryWhenDropped=false) _IRR_OVERRIDE_;
 
 	//! Opens a file for write access.
-	virtual IWriteFile* createAndWriteFile(const io::path& filename, bool append=false);
+	virtual IWriteFile* createAndWriteFile(const io::path& filename, bool append=false) _IRR_OVERRIDE_;
 
 	//! Adds an archive to the file system.
 	virtual bool addFileArchive(const io::path& filename,
@@ -60,93 +60,93 @@ public:
 			IFileArchive** retArchive = 0);
 
 	//! Adds an archive to the file system.
-	virtual bool addFileArchive(IFileArchive* archive);
+	virtual bool addFileArchive(IFileArchive* archive) _IRR_OVERRIDE_;
 
 	//! move the hirarchy of the filesystem. moves sourceIndex relative up or down
-	virtual bool moveFileArchive(u32 sourceIndex, s32 relative);
+	virtual bool moveFileArchive(u32 sourceIndex, s32 relative) _IRR_OVERRIDE_;
 
 	//! Adds an external archive loader to the engine.
-	virtual void addArchiveLoader(IArchiveLoader* loader);
+	virtual void addArchiveLoader(IArchiveLoader* loader) _IRR_OVERRIDE_;
 
 	//! Returns the total number of archive loaders added.
-	virtual u32 getArchiveLoaderCount() const;
+	virtual u32 getArchiveLoaderCount() const _IRR_OVERRIDE_;
 
 	//! Gets the archive loader by index.
-	virtual IArchiveLoader* getArchiveLoader(u32 index) const;
+	virtual IArchiveLoader* getArchiveLoader(u32 index) const _IRR_OVERRIDE_;
 
 	//! gets the file archive count
-	virtual u32 getFileArchiveCount() const;
+	virtual u32 getFileArchiveCount() const _IRR_OVERRIDE_;
 
 	//! gets an archive
-	virtual IFileArchive* getFileArchive(u32 index);
+	virtual IFileArchive* getFileArchive(u32 index) _IRR_OVERRIDE_;
 
 	//! removes an archive from the file system.
-	virtual bool removeFileArchive(u32 index);
+	virtual bool removeFileArchive(u32 index) _IRR_OVERRIDE_;
 
 	//! removes an archive from the file system.
-	virtual bool removeFileArchive(const io::path& filename);
+	virtual bool removeFileArchive(const io::path& filename) _IRR_OVERRIDE_;
 
 	//! Removes an archive from the file system.
-	virtual bool removeFileArchive(const IFileArchive* archive);
+	virtual bool removeFileArchive(const IFileArchive* archive) _IRR_OVERRIDE_;
 
 	//! Returns the string of the current working directory
-	virtual const io::path& getWorkingDirectory();
+	virtual const io::path& getWorkingDirectory() _IRR_OVERRIDE_;
 
 	//! Changes the current Working Directory to the string given.
 	//! The string is operating system dependent. Under Windows it will look
 	//! like this: "drive:\directory\sudirectory\"
-	virtual bool changeWorkingDirectoryTo(const io::path& newDirectory);
+	virtual bool changeWorkingDirectoryTo(const io::path& newDirectory) _IRR_OVERRIDE_;
 
 	//! Converts a relative path to an absolute (unique) path, resolving symbolic links
-	virtual io::path getAbsolutePath(const io::path& filename) const;
+	virtual io::path getAbsolutePath(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! Returns the directory a file is located in.
 	/** \param filename: The file to get the directory from */
-	virtual io::path getFileDir(const io::path& filename) const;
+	virtual io::path getFileDir(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! Returns the base part of a filename, i.e. the name without the directory
 	//! part. If no directory is prefixed, the full name is returned.
 	/** \param filename: The file to get the basename from */
-	virtual io::path getFileBasename(const io::path& filename, bool keepExtension=true) const;
+	virtual io::path getFileBasename(const io::path& filename, bool keepExtension=true) const _IRR_OVERRIDE_;
 
 	//! flatten a path and file name for example: "/you/me/../." becomes "/you"
-	virtual io::path& flattenFilename( io::path& directory, const io::path& root = "/" ) const;
+	virtual io::path& flattenFilename( io::path& directory, const io::path& root = "/" ) const _IRR_OVERRIDE_;
 
 	//! Get the relative filename, relative to the given directory
-	virtual path getRelativeFilename(const path& filename, const path& directory) const;
+	virtual path getRelativeFilename(const path& filename, const path& directory) const _IRR_OVERRIDE_;
 
-	virtual EFileSystemType setFileListSystem(EFileSystemType listType);
+	virtual EFileSystemType setFileListSystem(EFileSystemType listType) _IRR_OVERRIDE_;
 
 	//! Creates a list of files and directories in the current working directory
 	//! and returns it.
-	virtual IFileList* createFileList();
+	virtual IFileList* createFileList() _IRR_OVERRIDE_;
 
 	//! Creates an empty filelist
-	virtual IFileList* createEmptyFileList(const io::path& path, bool ignoreCase, bool ignorePaths);
+	virtual IFileList* createEmptyFileList(const io::path& path, bool ignoreCase, bool ignorePaths) _IRR_OVERRIDE_;
 
 	//! determines if a file exists and would be able to be opened.
-	virtual bool existFile(const io::path& filename) const;
+	virtual bool existFile(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! Creates a XML Reader from a file.
-	virtual IXMLReader* createXMLReader(const io::path& filename);
+	virtual IXMLReader* createXMLReader(const io::path& filename) _IRR_OVERRIDE_;
 
 	//! Creates a XML Reader from a file.
-	virtual IXMLReader* createXMLReader(IReadFile* file);
+	virtual IXMLReader* createXMLReader(IReadFile* file) _IRR_OVERRIDE_;
 
 	//! Creates a XML Reader from a file.
-	virtual IXMLReaderUTF8* createXMLReaderUTF8(const io::path& filename);
+	virtual IXMLReaderUTF8* createXMLReaderUTF8(const io::path& filename) _IRR_OVERRIDE_;
 
 	//! Creates a XML Reader from a file.
-	virtual IXMLReaderUTF8* createXMLReaderUTF8(IReadFile* file);
+	virtual IXMLReaderUTF8* createXMLReaderUTF8(IReadFile* file) _IRR_OVERRIDE_;
 
 	//! Creates a XML Writer from a file.
-	virtual IXMLWriter* createXMLWriter(const io::path& filename);
+	virtual IXMLWriter* createXMLWriter(const io::path& filename) _IRR_OVERRIDE_;
 
 	//! Creates a XML Writer from a file.
-	virtual IXMLWriter* createXMLWriter(IWriteFile* file);
+	virtual IXMLWriter* createXMLWriter(IWriteFile* file) _IRR_OVERRIDE_;
 
 	//! Creates a new empty collection of attributes, usable for serialization and more.
-	virtual IAttributes* createEmptyAttributes(video::IVideoDriver* driver);
+	virtual IAttributes* createEmptyAttributes(video::IVideoDriver* driver) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CGUIButton.h

@@ -29,34 +29,34 @@ namespace gui
 		virtual ~CGUIButton();
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! sets another skin independent font. if this is set to zero, the button uses the font of the skin.
-		virtual void setOverrideFont(IGUIFont* font=0);
+		virtual void setOverrideFont(IGUIFont* font=0) _IRR_OVERRIDE_;
 
 		//! Gets the override font (if any)
-		virtual IGUIFont* getOverrideFont() const;
+		virtual IGUIFont* getOverrideFont() const _IRR_OVERRIDE_;
 
 		//! Get the font which is used right now for drawing
-		virtual IGUIFont* getActiveFont() const;
+		virtual IGUIFont* getActiveFont() const _IRR_OVERRIDE_;
 
 		//! Sets an image which should be displayed on the button when it is in normal state.
-		virtual void setImage(video::ITexture* image=0);
+		virtual void setImage(video::ITexture* image=0) _IRR_OVERRIDE_;
 
 		//! Sets an image which should be displayed on the button when it is in normal state.
-		virtual void setImage(video::ITexture* image, const core::rect<s32>& pos);
+		virtual void setImage(video::ITexture* image, const core::rect<s32>& pos) _IRR_OVERRIDE_;
 
 		//! Sets an image which should be displayed on the button when it is in pressed state.
-		virtual void setPressedImage(video::ITexture* image=0);
+		virtual void setPressedImage(video::ITexture* image=0) _IRR_OVERRIDE_;
 
 		//! Sets an image which should be displayed on the button when it is in pressed state.
-		virtual void setPressedImage(video::ITexture* image, const core::rect<s32>& pos);
+		virtual void setPressedImage(video::ITexture* image, const core::rect<s32>& pos) _IRR_OVERRIDE_;
 
 		//! Sets the sprite bank used by the button
-		virtual void setSpriteBank(IGUISpriteBank* bank=0);
+		virtual void setSpriteBank(IGUISpriteBank* bank=0) _IRR_OVERRIDE_;
 
 		//! Sets the animated sprite for a specific button state
 		/** \param index: Number of the sprite within the sprite bank, use -1 for no sprite
@@ -70,40 +70,40 @@ namespace gui
 		//! Sets if the button should behave like a push button. Which means it
 		//! can be in two states: Normal or Pressed. With a click on the button,
 		//! the user can change the state of the button.
-		virtual void setIsPushButton(bool isPushButton=true);
+		virtual void setIsPushButton(bool isPushButton=true) _IRR_OVERRIDE_;
 
 		//! Checks whether the button is a push button
-		virtual bool isPushButton() const;
+		virtual bool isPushButton() const _IRR_OVERRIDE_;
 
 		//! Sets the pressed state of the button if this is a pushbutton
-		virtual void setPressed(bool pressed=true);
+		virtual void setPressed(bool pressed=true) _IRR_OVERRIDE_;
 
 		//! Returns if the button is currently pressed
-		virtual bool isPressed() const;
+		virtual bool isPressed() const _IRR_OVERRIDE_;
 
 		//! Sets if the button should use the skin to draw its border
-		virtual void setDrawBorder(bool border=true);
+		virtual void setDrawBorder(bool border=true) _IRR_OVERRIDE_;
 
 		//! Checks if the button face and border are being drawn
-		virtual bool isDrawingBorder() const;
+		virtual bool isDrawingBorder() const _IRR_OVERRIDE_;
 
 		//! Sets if the alpha channel should be used for drawing images on the button (default is false)
-		virtual void setUseAlphaChannel(bool useAlphaChannel=true);
+		virtual void setUseAlphaChannel(bool useAlphaChannel=true) _IRR_OVERRIDE_;
 
 		//! Checks if the alpha channel should be used for drawing images on the button
-		virtual bool isAlphaChannelUsed() const;
+		virtual bool isAlphaChannelUsed() const _IRR_OVERRIDE_;
 
 		//! Sets if the button should scale the button images to fit
-		virtual void setScaleImage(bool scaleImage=true);
+		virtual void setScaleImage(bool scaleImage=true) _IRR_OVERRIDE_;
 
 		//! Checks whether the button scales the used images
-		virtual bool isScalingImage() const;
+		virtual bool isScalingImage() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUICheckBox.h

@@ -23,36 +23,36 @@ namespace gui
 		CGUICheckBox(bool checked, IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle);
 
 		//! set if box is checked
-		virtual void setChecked(bool checked);
+		virtual void setChecked(bool checked) _IRR_OVERRIDE_;
 
 		//! returns if box is checked
-		virtual bool isChecked() const;
+		virtual bool isChecked() const _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the background
-		virtual void setDrawBackground(bool draw);
+		virtual void setDrawBackground(bool draw) _IRR_OVERRIDE_;
 
 		//! Checks if background drawing is enabled
 		/** \return true if background drawing is enabled, false otherwise */
-		virtual bool isDrawBackgroundEnabled() const;
+		virtual bool isDrawBackgroundEnabled() const _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the border
-		virtual void setDrawBorder(bool draw);
+		virtual void setDrawBorder(bool draw) _IRR_OVERRIDE_;
 
 		//! Checks if border drawing is enabled
 		/** \return true if border drawing is enabled, false otherwise */
-		virtual bool isDrawBorderEnabled() const;
+		virtual bool isDrawBorderEnabled() const _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIColorSelectDialog.h

@@ -31,13 +31,13 @@ namespace gui
 		virtual ~CGUIColorSelectDialog();
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
-		virtual video::SColor getColor();
-		virtual video::SColorHSL getColorHSL();
+		virtual video::SColor getColor() _IRR_OVERRIDE_;
+		virtual video::SColorHSL getColorHSL() _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIComboBox.h

@@ -30,55 +30,55 @@ namespace gui
 			s32 id, core::rect<s32> rectangle);
 
 		//! Returns amount of items in box
-		virtual u32 getItemCount() const;
+		virtual u32 getItemCount() const _IRR_OVERRIDE_;
 
 		//! returns string of an item. the idx may be a value from 0 to itemCount-1
-		virtual const wchar_t* getItem(u32 idx) const;
+		virtual const wchar_t* getItem(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Returns item data of an item. the idx may be a value from 0 to itemCount-1
-		virtual u32 getItemData(u32 idx) const;
+		virtual u32 getItemData(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Returns index based on item data
-		virtual s32 getIndexForItemData( u32 data ) const;
+		virtual s32 getIndexForItemData( u32 data ) const _IRR_OVERRIDE_;
 
 		//! adds an item and returns the index of it
-		virtual u32 addItem(const wchar_t* text, u32 data);
+		virtual u32 addItem(const wchar_t* text, u32 data) _IRR_OVERRIDE_;
 
 		//! Removes an item from the combo box.
-		virtual void removeItem(u32 id);
+		virtual void removeItem(u32 id) _IRR_OVERRIDE_;
 
 		//! deletes all items in the combo box
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! returns the text of the currently selected item
-		virtual const wchar_t* getText() const;
+		virtual const wchar_t* getText() const _IRR_OVERRIDE_;
 
 		//! returns id of selected item. returns -1 if no item is selected.
-		virtual s32 getSelected() const;
+		virtual s32 getSelected() const _IRR_OVERRIDE_;
 
 		//! sets the selected item. Set this to -1 if no item should be selected
-		virtual void setSelected(s32 idx);
+		virtual void setSelected(s32 idx) _IRR_OVERRIDE_;
 
 		//! sets the text alignment of the text part
-		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
+		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) _IRR_OVERRIDE_;
 
 		//! Set the maximal number of rows for the selection listbox
-		virtual void setMaxSelectionRows(u32 max);
+		virtual void setMaxSelectionRows(u32 max) _IRR_OVERRIDE_;
 
 		//! Get the maximimal number of rows for the selection listbox
-		virtual u32 getMaxSelectionRows() const;
+		virtual u32 getMaxSelectionRows() const _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIContextMenu.h

@@ -32,13 +32,13 @@ namespace gui
 		virtual ~CGUIContextMenu();
 
 		//! set behavior when menus are closed
-		virtual void setCloseHandling(ECONTEXT_MENU_CLOSE onClose);
+		virtual void setCloseHandling(ECONTEXT_MENU_CLOSE onClose) _IRR_OVERRIDE_;
 
 		//! get current behavior when the menue will be closed
-		virtual ECONTEXT_MENU_CLOSE getCloseHandling() const;
+		virtual ECONTEXT_MENU_CLOSE getCloseHandling() const _IRR_OVERRIDE_;
 
 		//! Returns amount of menu items
-		virtual u32 getItemCount() const;
+		virtual u32 getItemCount() const _IRR_OVERRIDE_;
 
 		//! Adds a menu item.
 		virtual u32 addItem(const wchar_t* text, s32 commandid,
@@ -49,74 +49,74 @@ namespace gui
 			bool hasSubMenu, bool checked, bool autoChecking);
 
 		//! Find a item which has the given CommandId starting from given index
-		virtual s32 findItemWithCommandId(s32 commandId, u32 idxStartSearch) const;
+		virtual s32 findItemWithCommandId(s32 commandId, u32 idxStartSearch) const _IRR_OVERRIDE_;
 
 		//! Adds a separator item to the menu
-		virtual void addSeparator();
+		virtual void addSeparator() _IRR_OVERRIDE_;
 
 		//! Returns text of the menu item.
-		virtual const wchar_t* getItemText(u32 idx) const;
+		virtual const wchar_t* getItemText(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Sets text of the menu item.
-		virtual void setItemText(u32 idx, const wchar_t* text);
+		virtual void setItemText(u32 idx, const wchar_t* text) _IRR_OVERRIDE_;
 
 		//! Returns if a menu item is enabled
-		virtual bool isItemEnabled(u32 idx) const;
+		virtual bool isItemEnabled(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Sets if the menu item should be enabled.
-		virtual void setItemEnabled(u32 idx, bool enabled);
+		virtual void setItemEnabled(u32 idx, bool enabled) _IRR_OVERRIDE_;
 
 		//! Returns if a menu item is checked
-		virtual bool isItemChecked(u32 idx) const;
+		virtual bool isItemChecked(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Sets if the menu item should be checked.
-		virtual void setItemChecked(u32 idx, bool enabled);
+		virtual void setItemChecked(u32 idx, bool enabled) _IRR_OVERRIDE_;
 
 		//! Removes a menu item
-		virtual void removeItem(u32 idx);
+		virtual void removeItem(u32 idx) _IRR_OVERRIDE_;
 
 		//! Removes all menu items
-		virtual void removeAllItems();
+		virtual void removeAllItems() _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Returns the selected item in the menu
-		virtual s32 getSelectedItem() const;
+		virtual s32 getSelectedItem() const _IRR_OVERRIDE_;
 
 		//! Returns a pointer to the submenu of an item.
 		//! \return Pointer to the submenu of an item.
-		virtual IGUIContextMenu* getSubMenu(u32 idx) const;
+		virtual IGUIContextMenu* getSubMenu(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Sets the visible state of this element.
-		virtual void setVisible(bool visible);
+		virtual void setVisible(bool visible) _IRR_OVERRIDE_;
 
 		//! should the element change the checked status on clicking
-		virtual void setItemAutoChecking(u32 idx, bool autoChecking);
+		virtual void setItemAutoChecking(u32 idx, bool autoChecking) _IRR_OVERRIDE_;
 
 		//! does the element change the checked status on clicking
-		virtual bool getItemAutoChecking(u32 idx) const;
+		virtual bool getItemAutoChecking(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Returns command id of a menu item
-		virtual s32 getItemCommandId(u32 idx) const;
+		virtual s32 getItemCommandId(u32 idx) const _IRR_OVERRIDE_;
 
 		//! Sets the command id of a menu item
-		virtual void setItemCommandId(u32 idx, s32 id);
+		virtual void setItemCommandId(u32 idx, s32 id) _IRR_OVERRIDE_;
 
 		//! Adds a sub menu from an element that already exists.
 		virtual void setSubMenu(u32 index, CGUIContextMenu* menu);
 
 		//! When an eventparent is set it receives events instead of the usual parent element
-		virtual void setEventParent(IGUIElement *parent);
+		virtual void setEventParent(IGUIElement *parent) _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	protected:
 

source/Irrlicht/CGUIEditBox.h

@@ -28,122 +28,122 @@ namespace gui
 		virtual ~CGUIEditBox();
 
 		//! Sets another skin independent font.
-		virtual void setOverrideFont(IGUIFont* font=0);
+		virtual void setOverrideFont(IGUIFont* font=0) _IRR_OVERRIDE_;
 
 		//! Gets the override font (if any)
 		/** \return The override font (may be 0) */
-		virtual IGUIFont* getOverrideFont() const;
+		virtual IGUIFont* getOverrideFont() const _IRR_OVERRIDE_;
 
 		//! Get the font which is used right now for drawing
 		/** Currently this is the override font when one is set and the
 		font of the active skin otherwise */
-		virtual IGUIFont* getActiveFont() const;
+		virtual IGUIFont* getActiveFont() const _IRR_OVERRIDE_;
 
 		//! Sets another color for the text.
-		virtual void setOverrideColor(video::SColor color);
+		virtual void setOverrideColor(video::SColor color) _IRR_OVERRIDE_;
 
 		//! Gets the override color
-		virtual video::SColor getOverrideColor() const;
+		virtual video::SColor getOverrideColor() const _IRR_OVERRIDE_;
 
 		//! Sets if the text should use the overide color or the
 		//! color in the gui skin.
-		virtual void enableOverrideColor(bool enable);
+		virtual void enableOverrideColor(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks if an override color is enabled
 		/** \return true if the override color is enabled, false otherwise */
-		virtual bool isOverrideColorEnabled(void) const;
+		virtual bool isOverrideColorEnabled(void) const _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the background
-		virtual void setDrawBackground(bool draw);
+		virtual void setDrawBackground(bool draw) _IRR_OVERRIDE_;
 
 		//! Checks if background drawing is enabled
-		virtual bool isDrawBackgroundEnabled() const;
+		virtual bool isDrawBackgroundEnabled() const _IRR_OVERRIDE_;
 
 		//! Turns the border on or off
-		virtual void setDrawBorder(bool border);
+		virtual void setDrawBorder(bool border) _IRR_OVERRIDE_;
 
 		//! Checks if border drawing is enabled
-		virtual bool isDrawBorderEnabled() const;
+		virtual bool isDrawBorderEnabled() const _IRR_OVERRIDE_;
 
 		//! Enables or disables word wrap for using the edit box as multiline text editor.
-		virtual void setWordWrap(bool enable);
+		virtual void setWordWrap(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks if word wrap is enabled
 		//! \return true if word wrap is enabled, false otherwise
-		virtual bool isWordWrapEnabled() const;
+		virtual bool isWordWrapEnabled() const _IRR_OVERRIDE_;
 
 		//! Enables or disables newlines.
 		/** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired,
 		instead a newline character will be inserted. */
-		virtual void setMultiLine(bool enable);
+		virtual void setMultiLine(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks if multi line editing is enabled
 		//! \return true if mult-line is enabled, false otherwise
-		virtual bool isMultiLineEnabled() const;
+		virtual bool isMultiLineEnabled() const _IRR_OVERRIDE_;
 
 		//! Enables or disables automatic scrolling with cursor position
 		//! \param enable: If set to true, the text will move around with the cursor position
-		virtual void setAutoScroll(bool enable);
+		virtual void setAutoScroll(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks to see if automatic scrolling is enabled
 		//! \return true if automatic scrolling is enabled, false if not
-		virtual bool isAutoScrollEnabled() const;
+		virtual bool isAutoScrollEnabled() const _IRR_OVERRIDE_;
 
 		//! Gets the size area of the text in the edit box
 		//! \return Returns the size in pixels of the text
-		virtual core::dimension2du getTextDimension();
+		virtual core::dimension2du getTextDimension() _IRR_OVERRIDE_;
 
 		//! Sets text justification
-		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
+		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Sets the new caption of this element.
-		virtual void setText(const wchar_t* text);
+		virtual void setText(const wchar_t* text) _IRR_OVERRIDE_;
 
 		//! Sets the maximum amount of characters which may be entered in the box.
 		//! \param max: Maximum amount of characters. If 0, the character amount is
 		//! infinity.
-		virtual void setMax(u32 max);
+		virtual void setMax(u32 max) _IRR_OVERRIDE_;
 
 		//! Returns maximum amount of characters, previously set by setMax();
-		virtual u32 getMax() const;
+		virtual u32 getMax() const _IRR_OVERRIDE_;
 
 		//! Set the character used for the cursor.
 		/** By default it's "_" */
-		virtual void setCursorChar(const wchar_t cursorChar);
+		virtual void setCursorChar(const wchar_t cursorChar) _IRR_OVERRIDE_;
 
 		//! Get the character used for the cursor.
-		virtual wchar_t getCursorChar() const;
+		virtual wchar_t getCursorChar() const _IRR_OVERRIDE_;
 
 		//! Set the blinktime for the cursor. 2x blinktime is one full cycle.
 		//** \param timeMs Blinktime in milliseconds. When set to 0 the cursor is constantly on without blinking */
-		virtual void setCursorBlinkTime(irr::u32 timeMs);
+		virtual void setCursorBlinkTime(irr::u32 timeMs) _IRR_OVERRIDE_;
 
 		//! Get the cursor blinktime
-		virtual irr::u32 getCursorBlinkTime() const;
+		virtual irr::u32 getCursorBlinkTime() const _IRR_OVERRIDE_;
 
 		//! Sets whether the edit box is a password box. Setting this to true will
 		/** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x
 		\param passwordBox: true to enable password, false to disable
 		\param passwordChar: the character that is displayed instead of letters */
-		virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*');
+		virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*') _IRR_OVERRIDE_;
 
 		//! Returns true if the edit box is currently a password box.
-		virtual bool isPasswordBox() const;
+		virtual bool isPasswordBox() const _IRR_OVERRIDE_;
 
 		//! Updates the absolute position, splits text if required
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	protected:
 		//! Breaks the single text line.

source/Irrlicht/CGUIFileOpenDialog.h

@@ -32,19 +32,19 @@ namespace gui
 		virtual ~CGUIFileOpenDialog();
 
 		//! returns the filename of the selected file. Returns NULL, if no file was selected.
-		virtual const wchar_t* getFileName() const;
+		virtual const wchar_t* getFileName() const _IRR_OVERRIDE_;
 
 		//! Returns the directory of the selected file. Returns NULL, if no directory was selected.
-		virtual const io::path& getDirectoryName();
+		virtual const io::path& getDirectoryName() _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 	protected:
 

source/Irrlicht/CGUIFont.h

@@ -54,29 +54,29 @@ public:
 			bool vcenter=false, const core::rect<s32>* clip=0);
 
 	//! returns the dimension of a text
-	virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;
+	virtual core::dimension2d<u32> getDimension(const wchar_t* text) const _IRR_OVERRIDE_;
 
 	//! Calculates the index of the character in the text which is on a specific position.
-	virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const;
+	virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const _IRR_OVERRIDE_;
 
 	//! Returns the type of this font
 	virtual EGUI_FONT_TYPE getType() const _IRR_OVERRIDE_ { return EGFT_BITMAP; }
 
 	//! set an Pixel Offset on Drawing ( scale position on width )
-	virtual void setKerningWidth (s32 kerning);
-	virtual void setKerningHeight (s32 kerning);
+	virtual void setKerningWidth (s32 kerning) _IRR_OVERRIDE_;
+	virtual void setKerningHeight (s32 kerning) _IRR_OVERRIDE_;
 
 	//! set an Pixel Offset on Drawing ( scale position on width )
-	virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const;
-	virtual s32 getKerningHeight() const;
+	virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const _IRR_OVERRIDE_;
+	virtual s32 getKerningHeight() const _IRR_OVERRIDE_;
 
 	//! gets the sprite bank
-	virtual IGUISpriteBank* getSpriteBank() const;
+	virtual IGUISpriteBank* getSpriteBank() const _IRR_OVERRIDE_;
 
 	//! returns the sprite number from a given character
-	virtual u32 getSpriteNoFromChar(const wchar_t *c) const;
+	virtual u32 getSpriteNoFromChar(const wchar_t *c) const _IRR_OVERRIDE_;
 
-	virtual void setInvisibleCharacters( const wchar_t *s );
+	virtual void setInvisibleCharacters( const wchar_t *s ) _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CGUIImage.h

@@ -26,37 +26,37 @@ namespace gui
 		virtual ~CGUIImage();
 
 		//! sets an image
-		virtual void setImage(video::ITexture* image);
+		virtual void setImage(video::ITexture* image) _IRR_OVERRIDE_;
 
 		//! Gets the image texture
-		virtual video::ITexture* getImage() const;
+		virtual video::ITexture* getImage() const _IRR_OVERRIDE_;
 
 		//! sets the color of the image
-		virtual void setColor(video::SColor color);
+		virtual void setColor(video::SColor color) _IRR_OVERRIDE_;
 
 		//! sets if the image should scale to fit the element
-		virtual void setScaleImage(bool scale);
+		virtual void setScaleImage(bool scale) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! sets if the image should use its alpha channel to draw itself
-		virtual void setUseAlphaChannel(bool use);
+		virtual void setUseAlphaChannel(bool use) _IRR_OVERRIDE_;
 
 		//! Gets the color of the image
-		virtual video::SColor getColor() const;
+		virtual video::SColor getColor() const _IRR_OVERRIDE_;
 
 		//! Returns true if the image is scaled to fit, false if not
-		virtual bool isImageScaled() const;
+		virtual bool isImageScaled() const _IRR_OVERRIDE_;
 
 		//! Returns true if the image is using the alpha channel, false if not
-		virtual bool isAlphaChannelUsed() const;
+		virtual bool isAlphaChannelUsed() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 		video::ITexture* Texture;

source/Irrlicht/CGUIInOutFader.h

@@ -24,29 +24,29 @@ namespace gui
 			s32 id, core::rect<s32> rectangle);
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Gets the color to fade out to or to fade in from.
-		virtual video::SColor getColor() const;
+		virtual video::SColor getColor() const _IRR_OVERRIDE_;
 
 		//! Sets the color to fade out to or to fade in from.
-		virtual void setColor(video::SColor color );
-		virtual void setColor(video::SColor source, video::SColor dest);
+		virtual void setColor(video::SColor color ) _IRR_OVERRIDE_;
+		virtual void setColor(video::SColor source, video::SColor dest) _IRR_OVERRIDE_;
 
 		//! Starts the fade in process.
-		virtual void fadeIn(u32 time);
+		virtual void fadeIn(u32 time) _IRR_OVERRIDE_;
 
 		//! Starts the fade out process.
-		virtual void fadeOut(u32 time);
+		virtual void fadeOut(u32 time) _IRR_OVERRIDE_;
 
 		//! Returns if the fade in or out process is done.
-		virtual bool isReady() const;
+		virtual bool isReady() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIListBox.h

@@ -31,105 +31,105 @@ namespace gui
 		virtual ~CGUIListBox();
 
 		//! returns amount of list items
-		virtual u32 getItemCount() const;
+		virtual u32 getItemCount() const _IRR_OVERRIDE_;
 
 		//! returns string of a list item. the id may be a value from 0 to itemCount-1
-		virtual const wchar_t* getListItem(u32 id) const;
+		virtual const wchar_t* getListItem(u32 id) const _IRR_OVERRIDE_;
 
 		//! adds an list item, returns id of item
-		virtual u32 addItem(const wchar_t* text);
+		virtual u32 addItem(const wchar_t* text) _IRR_OVERRIDE_;
 
 		//! clears the list
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! returns id of selected item. returns -1 if no item is selected.
-		virtual s32 getSelected() const;
+		virtual s32 getSelected() const _IRR_OVERRIDE_;
 
 		//! sets the selected item. Set this to -1 if no item should be selected
-		virtual void setSelected(s32 id);
+		virtual void setSelected(s32 id) _IRR_OVERRIDE_;
 
 		//! sets the selected item. Set this to -1 if no item should be selected
-		virtual void setSelected(const wchar_t *item);
+		virtual void setSelected(const wchar_t *item) _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! adds an list item with an icon
 		//! \param text Text of list entry
 		//! \param icon Sprite index of the Icon within the current sprite bank. Set it to -1 if you want no icon
 		//! \return
 		//! returns the id of the new created item
-		virtual u32 addItem(const wchar_t* text, s32 icon);
+		virtual u32 addItem(const wchar_t* text, s32 icon) _IRR_OVERRIDE_;
 
 		//! Returns the icon of an item
-		virtual s32 getIcon(u32 id) const;
+		virtual s32 getIcon(u32 id) const _IRR_OVERRIDE_;
 
 		//! removes an item from the list
-		virtual void removeItem(u32 id);
+		virtual void removeItem(u32 id) _IRR_OVERRIDE_;
 
 		//! get the the id of the item at the given absolute coordinates
-		virtual s32 getItemAt(s32 xpos, s32 ypos) const;
+		virtual s32 getItemAt(s32 xpos, s32 ypos) const _IRR_OVERRIDE_;
 
 		//! Sets the sprite bank which should be used to draw list icons. This font is set to the sprite bank of
 		//! the built-in-font by default. A sprite can be displayed in front of every list item.
 		//! An icon is an index within the icon sprite bank. Several default icons are available in the
 		//! skin through getIcon
-		virtual void setSpriteBank(IGUISpriteBank* bank);
+		virtual void setSpriteBank(IGUISpriteBank* bank) _IRR_OVERRIDE_;
 
 		//! set whether the listbox should scroll to newly selected items
-		virtual void setAutoScrollEnabled(bool scroll);
+		virtual void setAutoScrollEnabled(bool scroll) _IRR_OVERRIDE_;
 
 		//! returns true if automatic scrolling is enabled, false if not.
-		virtual bool isAutoScrollEnabled() const;
+		virtual bool isAutoScrollEnabled() const _IRR_OVERRIDE_;
 
 		//! Update the position and size of the listbox, and update the scrollbar
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 		//! set all item colors at given index to color
-		virtual void setItemOverrideColor(u32 index, video::SColor color);
+		virtual void setItemOverrideColor(u32 index, video::SColor color) _IRR_OVERRIDE_;
 
 		//! set all item colors of specified type at given index to color
-		virtual void setItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType, video::SColor color);
+		virtual void setItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType, video::SColor color) _IRR_OVERRIDE_;
 
 		//! clear all item colors at index
-		virtual void clearItemOverrideColor(u32 index);
+		virtual void clearItemOverrideColor(u32 index) _IRR_OVERRIDE_;
 
 		//! clear item color at index for given colortype
-		virtual void clearItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType);
+		virtual void clearItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) _IRR_OVERRIDE_;
 
 		//! has the item at index its color overwritten?
-		virtual bool hasItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const;
+		virtual bool hasItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const _IRR_OVERRIDE_;
 
 		//! return the overwrite color at given item index.
-		virtual video::SColor getItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const;
+		virtual video::SColor getItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const _IRR_OVERRIDE_;
 
 		//! return the default color which is used for the given colorType
-		virtual video::SColor getItemDefaultColor(EGUI_LISTBOX_COLOR colorType) const;
+		virtual video::SColor getItemDefaultColor(EGUI_LISTBOX_COLOR colorType) const _IRR_OVERRIDE_;
 
 		//! set the item at the given index
-		virtual void setItem(u32 index, const wchar_t* text, s32 icon);
+		virtual void setItem(u32 index, const wchar_t* text, s32 icon) _IRR_OVERRIDE_;
 
 		//! Insert the item at the given index
 		//! Return the index on success or -1 on failure.
-		virtual s32 insertItem(u32 index, const wchar_t* text, s32 icon);
+		virtual s32 insertItem(u32 index, const wchar_t* text, s32 icon) _IRR_OVERRIDE_;
 
 		//! Swap the items at the given indices
-		virtual void swapItems(u32 index1, u32 index2);
+		virtual void swapItems(u32 index1, u32 index2) _IRR_OVERRIDE_;
 
 		//! set global itemHeight
-		virtual void setItemHeight( s32 height );
+		virtual void setItemHeight( s32 height ) _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the background
-		virtual void setDrawBackground(bool draw);
+		virtual void setDrawBackground(bool draw) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIMenu.h

@@ -24,23 +24,23 @@ namespace gui
 		CGUIMenu(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle);
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! Updates the absolute position.
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 	protected:
 
-		virtual void recalculateSize();
+		virtual void recalculateSize() _IRR_OVERRIDE_;
 
 		//! returns the item highlight-area
-		virtual core::rect<s32> getHRect(const SItem& i, const core::rect<s32>& absolute) const;
+		virtual core::rect<s32> getHRect(const SItem& i, const core::rect<s32>& absolute) const _IRR_OVERRIDE_;
 
 		//! Gets drawing rect of Item
-		virtual core::rect<s32> getRect(const SItem& i, const core::rect<s32>& absolute) const;
+		virtual core::rect<s32> getRect(const SItem& i, const core::rect<s32>& absolute) const _IRR_OVERRIDE_;
 	};
 
 } // end namespace gui

source/Irrlicht/CGUIMeshViewer.h

@@ -28,22 +28,22 @@ namespace gui
 		virtual ~CGUIMeshViewer();
 
 		//! sets the mesh to be shown
-		virtual void setMesh(scene::IAnimatedMesh* mesh);
+		virtual void setMesh(scene::IAnimatedMesh* mesh) _IRR_OVERRIDE_;
 
 		//! Gets the displayed mesh
-		virtual scene::IAnimatedMesh* getMesh() const;
+		virtual scene::IAnimatedMesh* getMesh() const _IRR_OVERRIDE_;
 
 		//! sets the material
-		virtual void setMaterial(const video::SMaterial& material);
+		virtual void setMaterial(const video::SMaterial& material) _IRR_OVERRIDE_;
 
 		//! gets the material
-		virtual const video::SMaterial& getMaterial() const;
+		virtual const video::SMaterial& getMaterial() const _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIMessageBox.h

@@ -30,13 +30,13 @@ namespace gui
 		virtual ~CGUIMessageBox();
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUIModalScreen.h

@@ -23,34 +23,34 @@ namespace gui
 		CGUIModalScreen(IGUIEnvironment* environment, IGUIElement* parent, s32 id);
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! Removes a child.
-		virtual void removeChild(IGUIElement* child);
+		virtual void removeChild(IGUIElement* child) _IRR_OVERRIDE_;
 
 		//! Adds a child
-		virtual void addChild(IGUIElement* child);
+		virtual void addChild(IGUIElement* child) _IRR_OVERRIDE_;
 
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Updates the absolute position.
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Modalscreen is not a typical element, but rather acts like a state for it's children.
 		//! isVisible is overriden to give this a useful behavior, so that a modal will no longer
 		//! be active when its parent is invisible or all its children are invisible.
-		virtual bool isVisible() const;
+		virtual bool isVisible() const _IRR_OVERRIDE_;
 
 		//! Modals are infinite so every point is inside
-		virtual bool isPointInside(const core::position2d<s32>& point) const;
+		virtual bool isPointInside(const core::position2d<s32>& point) const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	protected:
 		virtual bool canTakeFocus(IGUIElement* target) const;

source/Irrlicht/CGUIScrollBar.h

@@ -29,52 +29,52 @@ namespace gui
 		virtual ~CGUIScrollBar();
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
-		virtual void OnPostRender(u32 timeMs);
+		virtual void OnPostRender(u32 timeMs) _IRR_OVERRIDE_;
 
 
 		//! gets the maximum value of the scrollbar.
-		virtual s32 getMax() const;
+		virtual s32 getMax() const _IRR_OVERRIDE_;
 
 		//! sets the maximum value of the scrollbar.
-		virtual void setMax(s32 max);
+		virtual void setMax(s32 max) _IRR_OVERRIDE_;
 
 		//! gets the minimum value of the scrollbar.
-		virtual s32 getMin() const;
+		virtual s32 getMin() const _IRR_OVERRIDE_;
 
 		//! sets the minimum value of the scrollbar.
-		virtual void setMin(s32 min);
+		virtual void setMin(s32 min) _IRR_OVERRIDE_;
 
 		//! gets the small step value
-		virtual s32 getSmallStep() const;
+		virtual s32 getSmallStep() const _IRR_OVERRIDE_;
 
 		//! sets the small step value
-		virtual void setSmallStep(s32 step);
+		virtual void setSmallStep(s32 step) _IRR_OVERRIDE_;
 
 		//! gets the large step value
-		virtual s32 getLargeStep() const;
+		virtual s32 getLargeStep() const _IRR_OVERRIDE_;
 
 		//! sets the large step value
-		virtual void setLargeStep(s32 step);
+		virtual void setLargeStep(s32 step) _IRR_OVERRIDE_;
 
 		//! gets the current position of the scrollbar
-		virtual s32 getPos() const;
+		virtual s32 getPos() const _IRR_OVERRIDE_;
 
 		//! sets the position of the scrollbar
-		virtual void setPos(s32 pos);
+		virtual void setPos(s32 pos) _IRR_OVERRIDE_;
 
 		//! updates the rectangle
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUISkin.h

@@ -30,49 +30,49 @@ namespace gui
 		virtual ~CGUISkin();
 
 		//! returns default color
-		virtual video::SColor getColor(EGUI_DEFAULT_COLOR color) const;
+		virtual video::SColor getColor(EGUI_DEFAULT_COLOR color) const _IRR_OVERRIDE_;
 
 		//! sets a default color
-		virtual void setColor(EGUI_DEFAULT_COLOR which, video::SColor newColor);
+		virtual void setColor(EGUI_DEFAULT_COLOR which, video::SColor newColor) _IRR_OVERRIDE_;
 
 		//! returns size for the given size type
-		virtual s32 getSize(EGUI_DEFAULT_SIZE size) const;
+		virtual s32 getSize(EGUI_DEFAULT_SIZE size) const _IRR_OVERRIDE_;
 
 		//! sets a default size
-		virtual void setSize(EGUI_DEFAULT_SIZE which, s32 size);
+		virtual void setSize(EGUI_DEFAULT_SIZE which, s32 size) _IRR_OVERRIDE_;
 
 		//! returns the default font
-		virtual IGUIFont* getFont(EGUI_DEFAULT_FONT which=EGDF_DEFAULT) const;
+		virtual IGUIFont* getFont(EGUI_DEFAULT_FONT which=EGDF_DEFAULT) const _IRR_OVERRIDE_;
 
 		//! sets a default font
-		virtual void setFont(IGUIFont* font, EGUI_DEFAULT_FONT which=EGDF_DEFAULT);
+		virtual void setFont(IGUIFont* font, EGUI_DEFAULT_FONT which=EGDF_DEFAULT) _IRR_OVERRIDE_;
 
 		//! sets the sprite bank used for drawing icons
-		virtual void setSpriteBank(IGUISpriteBank* bank);
+		virtual void setSpriteBank(IGUISpriteBank* bank) _IRR_OVERRIDE_;
 
 		//! gets the sprite bank used for drawing icons
-		virtual IGUISpriteBank* getSpriteBank() const;
+		virtual IGUISpriteBank* getSpriteBank() const _IRR_OVERRIDE_;
 
 		//! Returns a default icon
 		/** Returns the sprite index within the sprite bank */
-		virtual u32 getIcon(EGUI_DEFAULT_ICON icon) const;
+		virtual u32 getIcon(EGUI_DEFAULT_ICON icon) const _IRR_OVERRIDE_;
 
 		//! Sets a default icon
 		/** Sets the sprite index used for drawing icons like arrows,
 		close buttons and ticks in checkboxes
 		\param icon: Enum specifying which icon to change
 		\param index: The sprite index used to draw this icon */
-		virtual void setIcon(EGUI_DEFAULT_ICON icon, u32 index);
+		virtual void setIcon(EGUI_DEFAULT_ICON icon, u32 index) _IRR_OVERRIDE_;
 
 		//! Returns a default text.
 		/** For example for Message box button captions:
 		"OK", "Cancel", "Yes", "No" and so on. */
-		virtual const wchar_t* getDefaultText(EGUI_DEFAULT_TEXT text) const;
+		virtual const wchar_t* getDefaultText(EGUI_DEFAULT_TEXT text) const _IRR_OVERRIDE_;
 
 		//! Sets a default text.
 		/** For example for Message box button captions:
 		"OK", "Cancel", "Yes", "No" and so on. */
-		virtual void setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t* newText);
+		virtual void setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t* newText) _IRR_OVERRIDE_;
 
 		//! draws a standard 3d button pane
 		/** Used for drawing for example buttons in normal state.
@@ -212,17 +212,17 @@ namespace gui
 
 
 		//! get the type of this skin
-		virtual EGUI_SKIN_TYPE getType() const;
+		virtual EGUI_SKIN_TYPE getType() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the object.
 		//! Implement this to expose the attributes of your scene node animator for
 		//! scripting languages, editors, debuggers or xml serialization purposes.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the object.
 		//! Implement this to set the attributes of your scene node animator for
 		//! scripting languages, editors, debuggers or xml deserialization purposes.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUISpinBox.h

@@ -32,62 +32,62 @@ namespace gui
 		/** \param enable: If set to true, the override color, which can be set
 		with IGUIEditBox::setOverrideColor is used, otherwise the
 		EGDC_BUTTON_TEXT color of the skin. */
-		virtual IGUIEditBox* getEditBox() const;
+		virtual IGUIEditBox* getEditBox() const _IRR_OVERRIDE_;
 
 		//! set the current value of the spinbox
 		/** \param val: value to be set in the spinbox */
-		virtual void setValue(f32 val);
+		virtual void setValue(f32 val) _IRR_OVERRIDE_;
 
 		//! Get the current value of the spinbox
-		virtual f32 getValue() const;
+		virtual f32 getValue() const _IRR_OVERRIDE_;
 
 		//! set the range of values which can be used in the spinbox
 		/** \param min: minimum value
 		\param max: maximum value */
-		virtual void setRange(f32 min, f32 max);
+		virtual void setRange(f32 min, f32 max) _IRR_OVERRIDE_;
 
 		//! get the minimum value which can be used in the spinbox
-		virtual f32 getMin() const;
+		virtual f32 getMin() const _IRR_OVERRIDE_;
 
 		//! get the maximum value which can be used in the spinbox
-		virtual f32 getMax() const;
+		virtual f32 getMax() const _IRR_OVERRIDE_;
 
 		//! step size by which values are changed when pressing the spin buttons
 		/** \param step: stepsize used for value changes when pressing spin buttons */
-		virtual void setStepSize(f32 step=1.f);
+		virtual void setStepSize(f32 step=1.f) _IRR_OVERRIDE_;
 
 		//! returns the step size
-		virtual f32 getStepSize() const;
+		virtual f32 getStepSize() const _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! Draws the element and its children.
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Sets the new caption of the element
-		virtual void setText(const wchar_t* text);
+		virtual void setText(const wchar_t* text) _IRR_OVERRIDE_;
 
 		//! Returns caption of this element.
-		virtual const wchar_t* getText() const;
+		virtual const wchar_t* getText() const _IRR_OVERRIDE_;
 
 		//! Sets the number of decimal places to display.
 		//! Note that this also rounds the range to the same number of decimal places.
 		/** \param places: The number of decimal places to display, use -1 to reset */
-		virtual void setDecimalPlaces(s32 places);
+		virtual void setDecimalPlaces(s32 places) _IRR_OVERRIDE_;
 
 		//! Sets when the spinbox has to validate entered text.
 		/** \param validateOn Can be any combination of EGUI_SPINBOX_VALIDATION bit flags */
-		virtual void setValidateOn(u32 validateOn);
+		virtual void setValidateOn(u32 validateOn) _IRR_OVERRIDE_;
 
 		//! Gets when the spinbox has to validate entered text.
-		virtual u32 getValidateOn() const;
+		virtual u32 getValidateOn() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	protected:
 		virtual void verifyValueRange();

source/Irrlicht/CGUISpriteBank.h

@@ -32,19 +32,19 @@ public:
 	CGUISpriteBank(IGUIEnvironment* env);
 	virtual ~CGUISpriteBank();
 
-	virtual core::array< core::rect<s32> >& getPositions();
-	virtual core::array< SGUISprite >& getSprites();
+	virtual core::array< core::rect<s32> >& getPositions() _IRR_OVERRIDE_;
+	virtual core::array< SGUISprite >& getSprites() _IRR_OVERRIDE_;
 
-	virtual u32 getTextureCount() const;
-	virtual video::ITexture* getTexture(u32 index) const;
-	virtual void addTexture(video::ITexture* texture);
-	virtual void setTexture(u32 index, video::ITexture* texture);
+	virtual u32 getTextureCount() const _IRR_OVERRIDE_;
+	virtual video::ITexture* getTexture(u32 index) const _IRR_OVERRIDE_;
+	virtual void addTexture(video::ITexture* texture) _IRR_OVERRIDE_;
+	virtual void setTexture(u32 index, video::ITexture* texture) _IRR_OVERRIDE_;
 
 	//! Add the texture and use it for a single non-animated sprite.
-	virtual s32 addTextureAsSprite(video::ITexture* texture);
+	virtual s32 addTextureAsSprite(video::ITexture* texture) _IRR_OVERRIDE_;
 
 	//! clears sprites, rectangles and textures
-	virtual void clear();
+	virtual void clear() _IRR_OVERRIDE_;
 
 	//! Draws a sprite in 2d with position and color
 	virtual void draw2DSprite(u32 index, const core::position2di& pos, const core::rect<s32>* clip=0,

source/Irrlicht/CGUIStaticText.h

@@ -28,75 +28,75 @@ namespace gui
 		virtual ~CGUIStaticText();
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Sets another skin independent font.
-		virtual void setOverrideFont(IGUIFont* font=0);
+		virtual void setOverrideFont(IGUIFont* font=0) _IRR_OVERRIDE_;
 
 		//! Gets the override font (if any)
-		virtual IGUIFont* getOverrideFont() const;
+		virtual IGUIFont* getOverrideFont() const _IRR_OVERRIDE_;
 
 		//! Get the font which is used right now for drawing
-		virtual IGUIFont* getActiveFont() const;
+		virtual IGUIFont* getActiveFont() const _IRR_OVERRIDE_;
 
 		//! Sets another color for the text.
-		virtual void setOverrideColor(video::SColor color);
+		virtual void setOverrideColor(video::SColor color) _IRR_OVERRIDE_;
 
 		//! Sets another color for the background.
-		virtual void setBackgroundColor(video::SColor color);
+		virtual void setBackgroundColor(video::SColor color) _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the background
-		virtual void setDrawBackground(bool draw);
+		virtual void setDrawBackground(bool draw) _IRR_OVERRIDE_;
 
 		//! Gets the background color
-		virtual video::SColor getBackgroundColor() const;
+		virtual video::SColor getBackgroundColor() const _IRR_OVERRIDE_;
 
 		//! Checks if background drawing is enabled
-		virtual bool isDrawBackgroundEnabled() const;
+		virtual bool isDrawBackgroundEnabled() const _IRR_OVERRIDE_;
 
 		//! Sets whether to draw the border
-		virtual void setDrawBorder(bool draw);
+		virtual void setDrawBorder(bool draw) _IRR_OVERRIDE_;
 
 		//! Checks if border drawing is enabled
-		virtual bool isDrawBorderEnabled() const;
+		virtual bool isDrawBorderEnabled() const _IRR_OVERRIDE_;
 
 		//! Sets alignment mode for text
-		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
+		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) _IRR_OVERRIDE_;
 
 		//! Gets the override color
-		virtual video::SColor getOverrideColor() const;
+		virtual video::SColor getOverrideColor() const _IRR_OVERRIDE_;
 
 		//! Sets if the static text should use the overide color or the
 		//! color in the gui skin.
-		virtual void enableOverrideColor(bool enable);
+		virtual void enableOverrideColor(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks if an override color is enabled
-		virtual bool isOverrideColorEnabled() const;
+		virtual bool isOverrideColorEnabled() const _IRR_OVERRIDE_;
 
 		//! Set whether the text in this label should be clipped if it goes outside bounds
-		virtual void setTextRestrainedInside(bool restrainedInside);
+		virtual void setTextRestrainedInside(bool restrainedInside) _IRR_OVERRIDE_;
 
 		//! Checks if the text in this label should be clipped if it goes outside bounds
-		virtual bool isTextRestrainedInside() const;
+		virtual bool isTextRestrainedInside() const _IRR_OVERRIDE_;
 
 		//! Enables or disables word wrap for using the static text as
 		//! multiline text control.
-		virtual void setWordWrap(bool enable);
+		virtual void setWordWrap(bool enable) _IRR_OVERRIDE_;
 
 		//! Checks if word wrap is enabled
-		virtual bool isWordWrapEnabled() const;
+		virtual bool isWordWrapEnabled() const _IRR_OVERRIDE_;
 
 		//! Sets the new caption of this element.
-		virtual void setText(const wchar_t* text);
+		virtual void setText(const wchar_t* text) _IRR_OVERRIDE_;
 
 		//! Returns the height of the text in pixels when it is drawn.
-		virtual s32 getTextHeight() const;
+		virtual s32 getTextHeight() const _IRR_OVERRIDE_;
 
 		//! Returns the width of the current text, in the current font
-		virtual s32 getTextWidth() const;
+		virtual s32 getTextWidth() const _IRR_OVERRIDE_;
 
 		//! Updates the absolute position, splits text if word wrap is enabled
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Set whether the string should be interpreted as right-to-left (RTL) text
 		/** \note This component does not implement the Unicode bidi standard, the
@@ -104,16 +104,16 @@ namespace gui
 		main difference when RTL is enabled is that the linebreaks for multiline
 		elements are performed starting from the end.
 		*/
-		virtual void setRightToLeft(bool rtl);
+		virtual void setRightToLeft(bool rtl) _IRR_OVERRIDE_;
 
 		//! Checks if the text should be interpreted as right-to-left text
-		virtual bool isRightToLeft() const;
+		virtual bool isRightToLeft() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUITabControl.h

@@ -34,36 +34,36 @@ namespace gui
 
 		//! Returns number of this tab in tabcontrol. Can be accessed
 		//! later IGUITabControl::getTab() by this number.
-		virtual s32 getNumber() const;
+		virtual s32 getNumber() const _IRR_OVERRIDE_;
 
 		//! Sets the number
 		virtual void setNumber(s32 n);
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! sets if the tab should draw its background
-		virtual void setDrawBackground(bool draw=true);
+		virtual void setDrawBackground(bool draw=true) _IRR_OVERRIDE_;
 
 		//! sets the color of the background, if it should be drawn.
-		virtual void setBackgroundColor(video::SColor c);
+		virtual void setBackgroundColor(video::SColor c) _IRR_OVERRIDE_;
 
 		//! sets the color of the text
-		virtual void setTextColor(video::SColor c);
+		virtual void setTextColor(video::SColor c) _IRR_OVERRIDE_;
 
 		//! returns true if the tab is drawing its background, false if not
-		virtual bool isDrawingBackground() const;
+		virtual bool isDrawingBackground() const _IRR_OVERRIDE_;
 
 		//! returns the color of the background
-		virtual video::SColor getBackgroundColor() const;
+		virtual video::SColor getBackgroundColor() const _IRR_OVERRIDE_;
 
-		virtual video::SColor getTextColor() const;
+		virtual video::SColor getTextColor() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 		//! only for internal use by CGUITabControl
 		void refreshSkinColors();
@@ -92,79 +92,79 @@ namespace gui
 		virtual ~CGUITabControl();
 
 		//! Adds a tab
-		virtual IGUITab* addTab(const wchar_t* caption, s32 id=-1);
+		virtual IGUITab* addTab(const wchar_t* caption, s32 id=-1) _IRR_OVERRIDE_;
 
 		//! Adds a tab that has already been created
 		virtual void addTab(CGUITab* tab);
 
 		//! Insert the tab at the given index
-		virtual IGUITab* insertTab(s32 idx, const wchar_t* caption, s32 id=-1);
+		virtual IGUITab* insertTab(s32 idx, const wchar_t* caption, s32 id=-1) _IRR_OVERRIDE_;
 
 		//! Removes a tab from the tabcontrol
-		virtual void removeTab(s32 idx);
+		virtual void removeTab(s32 idx) _IRR_OVERRIDE_;
 
 		//! Clears the tabcontrol removing all tabs
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! Returns amount of tabs in the tabcontrol
-		virtual s32 getTabCount() const;
+		virtual s32 getTabCount() const _IRR_OVERRIDE_;
 
 		//! Returns a tab based on zero based index
-		virtual IGUITab* getTab(s32 idx) const;
+		virtual IGUITab* getTab(s32 idx) const _IRR_OVERRIDE_;
 
 		//! Brings a tab to front.
-		virtual bool setActiveTab(s32 idx);
+		virtual bool setActiveTab(s32 idx) _IRR_OVERRIDE_;
 
 		//! Brings a tab to front.
-		virtual bool setActiveTab(IGUITab *tab);
+		virtual bool setActiveTab(IGUITab *tab) _IRR_OVERRIDE_;
 
 		//! Returns which tab is currently active
-		virtual s32 getActiveTab() const;
+		virtual s32 getActiveTab() const _IRR_OVERRIDE_;
 
 		//! get the the id of the tab at the given absolute coordinates
-		virtual s32 getTabAt(s32 xpos, s32 ypos) const;
+		virtual s32 getTabAt(s32 xpos, s32 ypos) const _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Removes a child.
-		virtual void removeChild(IGUIElement* child);
+		virtual void removeChild(IGUIElement* child) _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 		//! Set the height of the tabs
-		virtual void setTabHeight( s32 height );
+		virtual void setTabHeight( s32 height ) _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 		//! Get the height of the tabs
-		virtual s32 getTabHeight() const;
+		virtual s32 getTabHeight() const _IRR_OVERRIDE_;
 
 		//! set the maximal width of a tab. Per default width is 0 which means "no width restriction".
-		virtual void setTabMaxWidth(s32 width );
+		virtual void setTabMaxWidth(s32 width ) _IRR_OVERRIDE_;
 
 		//! get the maximal width of a tab
-		virtual s32 getTabMaxWidth() const;
+		virtual s32 getTabMaxWidth() const _IRR_OVERRIDE_;
 
 		//! Set the alignment of the tabs
 		//! note: EGUIA_CENTER is not an option
-		virtual void setTabVerticalAlignment( gui::EGUI_ALIGNMENT alignment );
+		virtual void setTabVerticalAlignment( gui::EGUI_ALIGNMENT alignment ) _IRR_OVERRIDE_;
 
 		//! Get the alignment of the tabs
-		virtual gui::EGUI_ALIGNMENT getTabVerticalAlignment() const;
+		virtual gui::EGUI_ALIGNMENT getTabVerticalAlignment() const _IRR_OVERRIDE_;
 
 		//! Set the extra width added to tabs on each side of the text
-		virtual void setTabExtraWidth( s32 extraWidth );
+		virtual void setTabExtraWidth( s32 extraWidth ) _IRR_OVERRIDE_;
 
 		//! Get the extra width added to tabs on each side of the text
-		virtual s32 getTabExtraWidth() const;
+		virtual s32 getTabExtraWidth() const _IRR_OVERRIDE_;
 
 		//! Update the position of the element, decides scroll button status
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 	private:
 

source/Irrlicht/CGUITable.h

@@ -35,52 +35,52 @@ namespace gui
 
 		//! Adds a column
 		//! If columnIndex is outside the current range, do push new colum at the end
-		virtual void addColumn(const wchar_t* caption, s32 columnIndex=-1);
+		virtual void addColumn(const wchar_t* caption, s32 columnIndex=-1) _IRR_OVERRIDE_;
 
 		//! remove a column from the table
-		virtual void removeColumn(u32 columnIndex);
+		virtual void removeColumn(u32 columnIndex) _IRR_OVERRIDE_;
 
 		//! Returns the number of columns in the table control
-		virtual s32 getColumnCount() const;
+		virtual s32 getColumnCount() const _IRR_OVERRIDE_;
 
 		//! Makes a column active. This will trigger an ordering process.
 		/** \param idx: The id of the column to make active.
 		\return True if successful. */
-		virtual bool setActiveColumn(s32 columnIndex, bool doOrder=false);
+		virtual bool setActiveColumn(s32 columnIndex, bool doOrder=false) _IRR_OVERRIDE_;
 
 		//! Returns which header is currently active
-		virtual s32 getActiveColumn() const;
+		virtual s32 getActiveColumn() const _IRR_OVERRIDE_;
 
 		//! Returns the ordering used by the currently active column
-		virtual EGUI_ORDERING_MODE getActiveColumnOrdering() const;
+		virtual EGUI_ORDERING_MODE getActiveColumnOrdering() const _IRR_OVERRIDE_;
 
 		//! set a column width
-		virtual void setColumnWidth(u32 columnIndex, u32 width);
+		virtual void setColumnWidth(u32 columnIndex, u32 width) _IRR_OVERRIDE_;
 
 		//! Get the width of a column
-		virtual u32 getColumnWidth(u32 columnIndex) const;
+		virtual u32 getColumnWidth(u32 columnIndex) const _IRR_OVERRIDE_;
 
 		//! columns can be resized by drag 'n drop
-		virtual void setResizableColumns(bool resizable);
+		virtual void setResizableColumns(bool resizable) _IRR_OVERRIDE_;
 
 		//! can columns be resized by dran 'n drop?
-		virtual bool hasResizableColumns() const;
+		virtual bool hasResizableColumns() const _IRR_OVERRIDE_;
 
 		//! This tells the table control which ordering mode should be used when
 		//! a column header is clicked.
 		/** \param columnIndex: The index of the column header.
 		\param state: If true, a EGET_TABLE_HEADER_CHANGED message will be sent and you can order the table data as you whish.*/
 		//! \param mode: One of the modes defined in EGUI_COLUMN_ORDERING
-		virtual void setColumnOrdering(u32 columnIndex, EGUI_COLUMN_ORDERING mode);
+		virtual void setColumnOrdering(u32 columnIndex, EGUI_COLUMN_ORDERING mode) _IRR_OVERRIDE_;
 
 		//! Returns which row is currently selected
-		virtual s32 getSelected() const;
+		virtual s32 getSelected() const _IRR_OVERRIDE_;
 
 		//! set wich row is currently selected
-		virtual void setSelected( s32 index );
+		virtual void setSelected( s32 index ) _IRR_OVERRIDE_;
 
 		//! Returns amount of rows in the tabcontrol
-		virtual s32 getRowCount() const;
+		virtual s32 getRowCount() const _IRR_OVERRIDE_;
 
 		//! adds a row to the table
 		/** \param rowIndex: zero based index of rows. The row will be
@@ -89,16 +89,16 @@ namespace gui
 			than the actual number of rows by more than one, it
 			won't be created. Note that if you create a row that is
 			not at the end, there might be performance issues*/
-		virtual u32 addRow(u32 rowIndex);
+		virtual u32 addRow(u32 rowIndex) _IRR_OVERRIDE_;
 
 		//! Remove a row from the table
-		virtual void removeRow(u32 rowIndex);
+		virtual void removeRow(u32 rowIndex) _IRR_OVERRIDE_;
 
 		//! clear the table rows, but keep the columns intact
-		virtual void clearRows();
+		virtual void clearRows() _IRR_OVERRIDE_;
 
 		//! Swap two row positions. This is useful for a custom ordering algo.
-		virtual void swapRows(u32 rowIndexA, u32 rowIndexB);
+		virtual void swapRows(u32 rowIndexA, u32 rowIndexB) _IRR_OVERRIDE_;
 
 		//! This tells the table to start ordering all the rows. You
 		//! need to explicitly tell the table to reorder the rows when
@@ -106,52 +106,52 @@ namespace gui
 		//! the system more flexible and doesn't make you pay the cost
 		//! of ordering when adding a lot of rows.
 		//! \param columnIndex: When set to -1 the active column is used.
-		virtual void orderRows(s32 columnIndex=-1, EGUI_ORDERING_MODE mode=EGOM_NONE);
+		virtual void orderRows(s32 columnIndex=-1, EGUI_ORDERING_MODE mode=EGOM_NONE) _IRR_OVERRIDE_;
 
 
 		//! Set the text of a cell
-		virtual void setCellText(u32 rowIndex, u32 columnIndex, const core::stringw& text);
+		virtual void setCellText(u32 rowIndex, u32 columnIndex, const core::stringw& text) _IRR_OVERRIDE_;
 
 		//! Set the text of a cell, and set a color of this cell.
-		virtual void setCellText(u32 rowIndex, u32 columnIndex, const core::stringw& text, video::SColor color);
+		virtual void setCellText(u32 rowIndex, u32 columnIndex, const core::stringw& text, video::SColor color) _IRR_OVERRIDE_;
 
 		//! Set the data of a cell
 		//! data will not be serialized.
-		virtual void setCellData(u32 rowIndex, u32 columnIndex, void *data);
+		virtual void setCellData(u32 rowIndex, u32 columnIndex, void *data) _IRR_OVERRIDE_;
 
 		//! Set the color of a cell text
-		virtual void setCellColor(u32 rowIndex, u32 columnIndex, video::SColor color);
+		virtual void setCellColor(u32 rowIndex, u32 columnIndex, video::SColor color) _IRR_OVERRIDE_;
 
 		//! Get the text of a cell
-		virtual const wchar_t* getCellText(u32 rowIndex, u32 columnIndex ) const;
+		virtual const wchar_t* getCellText(u32 rowIndex, u32 columnIndex ) const _IRR_OVERRIDE_;
 
 		//! Get the data of a cell
-		virtual void* getCellData(u32 rowIndex, u32 columnIndex ) const;
+		virtual void* getCellData(u32 rowIndex, u32 columnIndex ) const _IRR_OVERRIDE_;
 
 		//! clears the table, deletes all items in the table
-		virtual void clear();
+		virtual void clear() _IRR_OVERRIDE_;
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent &event);
+		virtual bool OnEvent(const SEvent &event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Set flags, as defined in EGUI_TABLE_DRAW_FLAGS, which influence the layout
-		virtual void setDrawFlags(s32 flags);
+		virtual void setDrawFlags(s32 flags) _IRR_OVERRIDE_;
 
 		//! Get the flags, as defined in EGUI_TABLE_DRAW_FLAGS, which influence the layout
-		virtual s32 getDrawFlags() const;
+		virtual s32 getDrawFlags() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the object.
 		//! Implement this to expose the attributes of your scene node animator for
 		//! scripting languages, editors, debuggers or xml serialization purposes.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the object.
 		//! Implement this to set the attributes of your scene node animator for
 		//! scripting languages, editors, debuggers or xml deserialization purposes.
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
 
 	protected:
 		virtual void refreshControls();
@@ -161,7 +161,8 @@ namespace gui
 
 		struct Cell
 		{
-			Cell() : IsOverrideColor(false), Data(0)  {}
+			Cell() : IsOverrideColor(false), Data(0) {}
+
 			core::stringw Text;
 			core::stringw BrokenText;
 			bool IsOverrideColor;
@@ -172,12 +173,14 @@ namespace gui
 		struct Row
 		{
 			Row() {}
+
 			core::array<Cell> Items;
 		};
 
 		struct Column
 		{
 			Column() : Width(0), OrderingMode(EGCO_NONE) {}
+
 			core::stringw Name;
 			u32 Width;
 			EGUI_COLUMN_ORDERING OrderingMode;

source/Irrlicht/CGUIToolBar.h

@@ -24,13 +24,13 @@ namespace gui
 		CGUIToolBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle);
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Updates the absolute position.
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! Adds a button to the tool bar
 		virtual IGUIButton* addButton(s32 id=-1, const wchar_t* text=0,const wchar_t* tooltiptext=0,

source/Irrlicht/CGUITreeView.h

@@ -30,24 +30,24 @@ namespace gui
 		~CGUITreeViewNode();
 
 		//! returns the owner (tree view) of this node
-		virtual IGUITreeView* getOwner() const;
+		virtual IGUITreeView* getOwner() const _IRR_OVERRIDE_;
 
 		//! Returns the parent node of this node.
-		virtual IGUITreeViewNode* getParent() const;
+		virtual IGUITreeViewNode* getParent() const _IRR_OVERRIDE_;
 
 		//! returns the text of the node
 		virtual const wchar_t* getText() const
 		{ return Text.c_str(); }
 
 		//! sets the text of the node
-		virtual void setText( const wchar_t* text );
+		virtual void setText( const wchar_t* text ) _IRR_OVERRIDE_;
 
 		//! returns the icon text of the node
 		virtual const wchar_t* getIcon() const
 		{ return Icon.c_str(); }
 
 		//! sets the icon text of the node
-		virtual void setIcon( const wchar_t* icon );
+		virtual void setIcon( const wchar_t* icon ) _IRR_OVERRIDE_;
 
 		//! returns the image index of the node
 		virtual u32 getImageIndex() const
@@ -96,7 +96,7 @@ namespace gui
 		{ return Children.getSize(); }
 
 		//! removes all children (recursive) from this node
-		virtual void clearChildren();
+		virtual void clearChildren() _IRR_OVERRIDE_;
 
 		//! returns true if this node has child nodes
 		virtual bool hasChildren() const
@@ -175,50 +175,50 @@ namespace gui
 				IReferenceCounted*			data2 = 0 );
 
 		//! Return the first child note from this node.
-		virtual IGUITreeViewNode* getFirstChild() const;
+		virtual IGUITreeViewNode* getFirstChild() const _IRR_OVERRIDE_;
 
 		//! Return the last child note from this node.
-		virtual IGUITreeViewNode* getLastChild() const;
+		virtual IGUITreeViewNode* getLastChild() const _IRR_OVERRIDE_;
 
 		//! Returns the preverse sibling node from this node.
-		virtual IGUITreeViewNode* getPrevSibling() const;
+		virtual IGUITreeViewNode* getPrevSibling() const _IRR_OVERRIDE_;
 
 		//! Returns the next sibling node from this node.
-		virtual IGUITreeViewNode* getNextSibling() const;
+		virtual IGUITreeViewNode* getNextSibling() const _IRR_OVERRIDE_;
 
 		//! Returns the next visible (expanded, may be out of scrolling) node from this node.
-		virtual IGUITreeViewNode* getNextVisible() const;
+		virtual IGUITreeViewNode* getNextVisible() const _IRR_OVERRIDE_;
 
 		//! Deletes a child node.
-		virtual bool deleteChild( IGUITreeViewNode* child );
+		virtual bool deleteChild( IGUITreeViewNode* child ) _IRR_OVERRIDE_;
 
 		//! Moves a child node one position up.
-		virtual bool moveChildUp( IGUITreeViewNode* child );
+		virtual bool moveChildUp( IGUITreeViewNode* child ) _IRR_OVERRIDE_;
 
 		//! Moves a child node one position down.
-		virtual bool moveChildDown( IGUITreeViewNode* child );
+		virtual bool moveChildDown( IGUITreeViewNode* child ) _IRR_OVERRIDE_;
 
 		//! Returns true if the node is expanded (children are visible).
 		virtual bool getExpanded() const
 		{ return Expanded; }
 
 		//! Sets if the node is expanded.
-		virtual void setExpanded( bool expanded );
+		virtual void setExpanded( bool expanded ) _IRR_OVERRIDE_;
 
 		//! Returns true if the node is currently selected.
-		virtual bool getSelected() const;
+		virtual bool getSelected() const _IRR_OVERRIDE_;
 
 		//! Sets this node as selected.
-		virtual void setSelected( bool selected );
+		virtual void setSelected( bool selected ) _IRR_OVERRIDE_;
 
 		//! Returns true if this node is the root node.
-		virtual bool isRoot() const;
+		virtual bool isRoot() const _IRR_OVERRIDE_;
 
 		//! Returns the level of this node.
-		virtual s32 getLevel() const;
+		virtual s32 getLevel() const _IRR_OVERRIDE_;
 
 		//! Returns true if this node is visible (all parents are expanded).
-		virtual bool isVisible() const;
+		virtual bool isVisible() const _IRR_OVERRIDE_;
 
 	private:
 
@@ -266,20 +266,20 @@ namespace gui
 		{ LinesVisible = visible; }
 
 		//! called if an event happened.
-		virtual bool OnEvent( const SEvent &event );
+		virtual bool OnEvent( const SEvent &event ) _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Sets the font which should be used as icon font. This font is set to the Irrlicht engine
 		//! built-in-font by default. Icons can be displayed in front of every list item.
 		//! An icon is a string, displayed with the icon font. When using the build-in-font of the
 		//! Irrlicht engine as icon font, the icon strings defined in GUIIcons.h can be used.
-		virtual void setIconFont( IGUIFont* font );
+		virtual void setIconFont( IGUIFont* font ) _IRR_OVERRIDE_;
 
 		//! Sets the image list which should be used for the image and selected image of every node.
 		//! The default is 0 (no images).
-		virtual void setImageList( IGUIImageList* imageList );
+		virtual void setImageList( IGUIImageList* imageList ) _IRR_OVERRIDE_;
 
 		//! Returns the image list which is used for the nodes.
 		virtual IGUIImageList* getImageList() const

source/Irrlicht/CGUIWindow.h

@@ -27,50 +27,50 @@ namespace gui
 		virtual ~CGUIWindow();
 
 		//! called if an event happened.
-		virtual bool OnEvent(const SEvent& event);
+		virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_;
 
 		//! update absolute position
-		virtual void updateAbsolutePosition();
+		virtual void updateAbsolutePosition() _IRR_OVERRIDE_;
 
 		//! draws the element and its children
-		virtual void draw();
+		virtual void draw() _IRR_OVERRIDE_;
 
 		//! Returns pointer to the close button
-		virtual IGUIButton* getCloseButton() const;
+		virtual IGUIButton* getCloseButton() const _IRR_OVERRIDE_;
 
 		//! Returns pointer to the minimize button
-		virtual IGUIButton* getMinimizeButton() const;
+		virtual IGUIButton* getMinimizeButton() const _IRR_OVERRIDE_;
 
 		//! Returns pointer to the maximize button
-		virtual IGUIButton* getMaximizeButton() const;
+		virtual IGUIButton* getMaximizeButton() const _IRR_OVERRIDE_;
 
 		//! Returns true if the window is draggable, false if not
-		virtual bool isDraggable() const;
+		virtual bool isDraggable() const _IRR_OVERRIDE_;
 
 		//! Sets whether the window is draggable
-		virtual void setDraggable(bool draggable);
+		virtual void setDraggable(bool draggable) _IRR_OVERRIDE_;
 
 		//! Set if the window background will be drawn
-		virtual void setDrawBackground(bool draw);
+		virtual void setDrawBackground(bool draw) _IRR_OVERRIDE_;
 
 		//! Get if the window background will be drawn
-		virtual bool getDrawBackground() const;
+		virtual bool getDrawBackground() const _IRR_OVERRIDE_;
 
 		//! Set if the window titlebar will be drawn
 		//! Note: If the background is not drawn, then the titlebar is automatically also not drawn
-		virtual void setDrawTitlebar(bool draw);
+		virtual void setDrawTitlebar(bool draw) _IRR_OVERRIDE_;
 
 		//! Get if the window titlebar will be drawn
-		virtual bool getDrawTitlebar() const;
+		virtual bool getDrawTitlebar() const _IRR_OVERRIDE_;
 
 		//! Returns the rectangle of the drawable area (without border and without titlebar)
-		virtual core::rect<s32> getClientRect() const;
+		virtual core::rect<s32> getClientRect() const _IRR_OVERRIDE_;
 
 		//! Writes attributes of the element.
-		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const _IRR_OVERRIDE_;
 
 		//! Reads attributes of the element
-		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) _IRR_OVERRIDE_;
 
 	protected:
 

source/Irrlicht/CImage.h

@@ -43,55 +43,55 @@ public:
 	virtual void unlock() _IRR_OVERRIDE_ {}
 
 	//! Returns width and height of image data.
-	virtual const core::dimension2d<u32>& getDimension() const;
+	virtual const core::dimension2d<u32>& getDimension() const _IRR_OVERRIDE_;
 
 	//! Returns bits per pixel.
-	virtual u32 getBitsPerPixel() const;
+	virtual u32 getBitsPerPixel() const _IRR_OVERRIDE_;
 
 	//! Returns bytes per pixel
-	virtual u32 getBytesPerPixel() const;
+	virtual u32 getBytesPerPixel() const _IRR_OVERRIDE_;
 
 	//! Returns image data size in bytes
-	virtual u32 getImageDataSizeInBytes() const;
+	virtual u32 getImageDataSizeInBytes() const _IRR_OVERRIDE_;
 
 	//! Returns image data size in pixels
-	virtual u32 getImageDataSizeInPixels() const;
+	virtual u32 getImageDataSizeInPixels() const _IRR_OVERRIDE_;
 
 	//! returns mask for red value of a pixel
-	virtual u32 getRedMask() const;
+	virtual u32 getRedMask() const _IRR_OVERRIDE_;
 
 	//! returns mask for green value of a pixel
-	virtual u32 getGreenMask() const;
+	virtual u32 getGreenMask() const _IRR_OVERRIDE_;
 
 	//! returns mask for blue value of a pixel
-	virtual u32 getBlueMask() const;
+	virtual u32 getBlueMask() const _IRR_OVERRIDE_;
 
 	//! returns mask for alpha value of a pixel
-	virtual u32 getAlphaMask() const;
+	virtual u32 getAlphaMask() const _IRR_OVERRIDE_;
 
 	//! returns a pixel
-	virtual SColor getPixel(u32 x, u32 y) const;
+	virtual SColor getPixel(u32 x, u32 y) const _IRR_OVERRIDE_;
 
 	//! sets a pixel
-	virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false );
+	virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false ) _IRR_OVERRIDE_;
 
 	//! returns the color format
-	virtual ECOLOR_FORMAT getColorFormat() const;
+	virtual ECOLOR_FORMAT getColorFormat() const _IRR_OVERRIDE_;
 
 	//! returns pitch of image
 	virtual u32 getPitch() const _IRR_OVERRIDE_ { return Pitch; }
 
 	//! copies this surface into another, scaling it to fit.
-	virtual void copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format, u32 pitch=0);
+	virtual void copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format, u32 pitch=0) _IRR_OVERRIDE_;
 
 	//! copies this surface into another, scaling it to fit.
-	virtual void copyToScaling(IImage* target);
+	virtual void copyToScaling(IImage* target) _IRR_OVERRIDE_;
 
 	//! copies this surface into another
-	virtual void copyTo(IImage* target, const core::position2d<s32>& pos=core::position2d<s32>(0,0));
+	virtual void copyTo(IImage* target, const core::position2d<s32>& pos=core::position2d<s32>(0,0)) _IRR_OVERRIDE_;
 
 	//! copies this surface into another
-	virtual void copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect=0);
+	virtual void copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect=0) _IRR_OVERRIDE_;
 
 	//! copies this surface into another, using the alpha mask, an cliprect and a color to add with
 	virtual void copyToWithAlpha(IImage* target, const core::position2d<s32>& pos,
@@ -99,17 +99,17 @@ public:
 			const core::rect<s32>* clipRect = 0);
 
 	//! copies this surface into another, scaling it to fit, appyling a box filter
-	virtual void copyToScalingBoxFilter(IImage* target, s32 bias = 0, bool blend = false);
+	virtual void copyToScalingBoxFilter(IImage* target, s32 bias = 0, bool blend = false) _IRR_OVERRIDE_;
 
 	//! fills the surface with given color
-	virtual void fill(const SColor &color);
+	virtual void fill(const SColor &color) _IRR_OVERRIDE_;
 
 	//! Inform whether the image is compressed
-	virtual bool isCompressed() const;
+	virtual bool isCompressed() const _IRR_OVERRIDE_;
 
 	//! Check whether the image has MipMaps
 	/** \return True if image has MipMaps, else false. */
-	virtual bool hasMipMaps() const;
+	virtual bool hasMipMaps() const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CImageLoaderBMP.h

@@ -75,13 +75,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CImageLoaderDDS.h

@@ -197,13 +197,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 };
 
 

source/Irrlicht/CImageLoaderJPG.h

@@ -43,13 +43,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CImageLoaderPCX.h

@@ -63,13 +63,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 };
 

source/Irrlicht/CImageLoaderPNG.h

@@ -27,13 +27,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".png")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 };
 
 

source/Irrlicht/CImageLoaderPPM.h

@@ -31,13 +31,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 private:
 	//! read the next token from file

source/Irrlicht/CImageLoaderPSD.h

@@ -48,13 +48,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 private:
 

source/Irrlicht/CImageLoaderRGB.h

@@ -138,13 +138,13 @@ public:
 
 	//! returns true if the file maybe is able to be loaded by this class
 	//! based on the file extension (e.g. ".tga")
-	virtual bool isALoadableFileExtension(const io::path& filename) const;
+	virtual bool isALoadableFileExtension(const io::path& filename) const _IRR_OVERRIDE_;
 
 	//! returns true if the file maybe is able to be loaded by this class
-	virtual bool isALoadableFileFormat(io::IReadFile* file) const;
+	virtual bool isALoadableFileFormat(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 	//! creates a surface from the file
-	virtual IImage* loadImage(io::IReadFile* file) const;
+	virtual IImage* loadImage(io::IReadFile* file) const _IRR_OVERRIDE_;
 
 private: