More work on getting documentation ready for doxygen generation

BansheeEditor/Include/BsBuiltinEditorResources.h

@@ -10,18 +10,18 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Types of valid icons used when viewing the project library.
+	/** @addtogroup Utility-Editor
+	 *  @{
 	 */
+
+	/**	Types of valid icons used when viewing the project library. */
 	enum class ProjectIcon
 	{
 		Folder, Mesh, Font, Texture, PlainText, ScriptCode, SpriteTexture, Shader, ShaderInclude, Material, Prefab, GUISkin,
 		PhysicsMaterial, PhysicsMesh
 	};
 
-	/**
-	 * @brief	Types of icons that may be displayed on the tool bar.
-	 */
+	/**	Types of icons that may be displayed on the tool bar. */
 	enum class ToolbarIcon
 	{
 		NewCamera, NewRenderable, NewPointLight, NewDirLight, NewSpotLight, NewSceneObject, NewCube, NewSphere, NewCone, 
@@ -29,116 +29,80 @@ namespace BansheeEngine
 		SaveScene
 	};
 
-	/**
-	 * @brief	Types of icons that may be displayed in the scene window.
-	 */
+	/**	Types of icons that may be displayed in the scene window. */
 	enum class SceneWindowIcon
 	{
 		View, Move, Rotate, Scale, Pivot, Center, Local, World, MoveSnap, RotateSnap
 	};
 
-	/**
-	 * @brief	Types of icons that may be displayed in the inspector window.
-	 */
+	/**	Types of icons that may be displayed in the inspector window. */
 	enum class InspectorWindowIcon
 	{
 		Create, Clone, Clear, Resize, Delete, MoveUp, MoveDown, Edit, Apply, Add, Cancel
 	};
 
-	/**
-	 * @brief	Types of icons that may be displayed in the library window.
-	 */
+	/**	Types of icons that may be displayed in the library window. */
 	enum class LibraryWindowIcon
 	{
 		Home, Up, Clear, Options
 	};
 
-	/**
-	 * @brief	Types of icons used in various areas throughout the editor.
-	 */
+	/**	Types of icons used in various areas throughout the editor. */
 	enum class EditorIcon
 	{
 		XBtn
 	};
 
-	/**
-	 * @brief	Types of icons to be used along with log messages depending on their severity.
-	 */
+	/**	Types of icons to be used along with log messages depending on their severity. */
 	enum class LogMessageIcon
 	{
 		Info, Warning, Error
 	};
 
-	/**
-	 * @brief	Contains a set of built-in resources used by the editor.
-	 */
+	/**	Contains a set of built-in resources used by the editor. */
 	class BS_ED_EXPORT BuiltinEditorResources : public BansheeEngine::Module<BuiltinEditorResources>
 	{
 	public:
 		BuiltinEditorResources();
 		~BuiltinEditorResources();
 
-		/**
-		 * @brief	Returns the default editor GUI skin.
-		 */
+		/**	Returns the default editor GUI skin. */
 		const HGUISkin& getSkin() const { return mSkin; }
 
 		/** Returns the default font used by the editor. */
 		const HFont& getDefaultFont() const { return mDefaultFont; }
 
-		/**
-		 * @brief	Creates a material used for docking drop overlay used by the editor.
-		 */
+		/**	Creates a material used for docking drop overlay used by the editor. */
 		HMaterial createDockDropOverlayMaterial() const;
 
-		/**
-		 * @brief	Creates a material used for rendering the scene grid.
-		 */
+		/**	Creates a material used for rendering the scene grid. */
 		HMaterial createSceneGridMaterial() const;
 
-		/**
-		 * @brief	Creates a material used for picking non-transparent objects in scene view.
-		 */
+		/**	Creates a material used for picking non-transparent objects in scene view. */
 		HMaterial createPicking(CullingMode cullMode) const;
 
-		/**
-		 * @brief	Creates a material used for picking transparent objects in scene view.
-		 */
+		/**	Creates a material used for picking transparent objects in scene view. */
 		HMaterial createPickingAlpha(CullingMode cullMode) const;
 
-		/**
-		 * @brief	Creates a material used for rendering wireframe gizmos.
-		 */
+		/**	Creates a material used for rendering wireframe gizmos. */
 		HMaterial createWireGizmoMat() const;
 
-		/**
-		 * @brief	Creates a material used for rendering solid gizmos.
-		 */
+		/**	Creates a material used for rendering solid gizmos. */
 		HMaterial createSolidGizmoMat() const;
 
-		/**
-		 * @brief	Creates a material used for rendering icon gizmos.
-		 */
+		/**	Creates a material used for rendering icon gizmos. */
 		HMaterial createIconGizmoMat() const;
 
-		/**
-		 * @brief	Creates a material used for picking non-transparent gizmos.
-		 */
+		/**	Creates a material used for picking non-transparent gizmos. */
 		HMaterial createGizmoPickingMat() const;
 
-		/**
-		 * @brief	Creates a material used for picking transparent gizmos.
-		 */
+		/**	Creates a material used for picking transparent gizmos. */
 		HMaterial createAlphaGizmoPickingMat() const;
 
-		/**
-		 * @brief	Creates a material used for rendering wireframe handles.
-		 */
+		/**	Creates a material used for rendering wireframe handles. */
 		HMaterial createWireHandleMat() const;
 
-		/**
-		 * @brief	Creates a material used for rendering solid handles.
-		 */
+		/**	Creates a material used for rendering solid handles. */
 		HMaterial createSolidHandleMat() const;
 
 		/** Creates a material used for rendering text for gizmos and handles. */
@@ -147,65 +111,43 @@ namespace BansheeEngine
 		/** Creates a material used for clearing the alpha channel of the handle rendering texture. */
 		HMaterial createHandleClearAlphaMat() const;
 
-		/**
-		 * @brief	Creates a material used for displaying selected objects.
-		 */
+		/**	Creates a material used for displaying selected objects. */
 		HMaterial createSelectionMat() const;
 
 		/**
-		 * @brief	Retrieves an icon that represents a specific resource type
-		 *			that may be displayed when viewing the project library.
+		 * Retrieves an icon that represents a specific resource type that may be displayed when viewing the project 
+		 * library.
 		 */
 		HSpriteTexture getLibraryIcon(ProjectIcon icon, int size) const;
 
-		/**
-		 * @brief	Retrieves an icon that may be displayed on the main window's toolbar.
-		 */
+		/**	Retrieves an icon that may be displayed on the main window's toolbar. */
 		HSpriteTexture getToolbarIcon(ToolbarIcon icon) const;
 
-		/**
-		 * @brief	Retrieves an icon that may be displayed on the scene window.
-		 */
+		/**	Retrieves an icon that may be displayed on the scene window. */
 		GUIContentImages getSceneWindowIcon(SceneWindowIcon icon) const;
 
-		/**
-		 * @brief	Retrieves an icon that may be displayed on the library window.
-		 */
+		/**	Retrieves an icon that may be displayed on the library window. */
 		HSpriteTexture getLibraryWindowIcon(LibraryWindowIcon icon) const;
 
-		/**
-		 * @brief	Retrieves an icon that may be displayed on the inspector window.
-		 */
+		/**	Retrieves an icon that may be displayed on the inspector window. */
 		HSpriteTexture getInspectorWindowIcon(InspectorWindowIcon icon) const;
 
-		/**
-		 * @brief	Retrieves an icon that represents a specific generic editor icon.
-		 */
+		/**	Retrieves an icon that represents a specific generic editor icon. */
 		HSpriteTexture getIcon(EditorIcon icon) const;
 
-		/**
-		 * @brief	Retrieves an icon that represents a specific log message type.
-		 */
+		/**	Retrieves an icon that represents a specific log message type. */
 		HSpriteTexture getLogMessageIcon(LogMessageIcon icon, UINT32 size, bool dark) const;
 
-		/**
-		 * @brief	Returns text contained in the default "empty" shader.
-		 */
+		/**	Returns text contained in the default "empty" shader. */
 		WString getEmptyShaderCode() const;
 
-		/**
-		 * @brief	Returns text contained in the default "empty" C# script.
-		 */
+		/**	Returns text contained in the default "empty" C# script. */
 		WString getEmptyCSScriptCode() const;
 
-		/**
-		 * @brief	Returns path to the builtin shader include folder, relative to the working directory.
-		 */
+		/**	Returns path to the builtin shader include folder, relative to the working directory. */
 		static Path getShaderIncludeFolder();
 
-		/**
-		 * @brief	Returns path to the default widget layout file, relative to the working directory.
-		 */
+		/**	Returns path to the default widget layout file, relative to the working directory. */
 		static Path getDefaultWidgetLayoutPath();
 
 		static const String ObjectFieldStyleName;
@@ -220,37 +162,29 @@ namespace BansheeEngine
 
 	private:
 		/**
-		 * @brief	Imports all necessary resources and converts them to engine-ready format.
+		 * Imports all necessary resources and converts them to engine-ready format.
 		 *
-		 * @note	Normally you only want to use this during development phase and then ship
-		 *			with engine-ready format only.
+		 * @note	
+		 * Normally you only want to use this during development phase and then ship with engine-ready format only.
 		 */
 		void preprocess();
 
-		/**
-		 * @brief	Generates the default editor skin and all GUI element styles.
-		 */
+		/**	Generates the default editor skin and all GUI element styles. */
 		GUISkinPtr generateGUISkin();
 
 		/**
-		 * @brief	Generates different sizes of resource icons. Expects maximum sizes of the icons to already be present.
-		 * 			Resulting textures will be saved to the same directory the maximum size textures are in.
+		 * Generates different sizes of resource icons. Expects maximum sizes of the icons to already be present. Resulting
+		 * textures will be saved to the same directory the maximum size textures are in.
 		 */
 		void generateResourceIcons(const Path& inputFolder, const ResourceManifestPtr& resourceManifest);
 
-		/**
-		 * @brief	Loads a GUI skin texture with the specified filename.
-		 */
+		/**	Loads a GUI skin texture with the specified filename. */
 		HSpriteTexture getGUITexture(const WString& name) const;
 
-		/**
-		 * @brief	Loads a GUI icon with the specified filename.
-		 */
+		/**	Loads a GUI icon with the specified filename. */
 		HSpriteTexture getGUIIcon(const WString& name) const;
 
-		/**
-		 * @brief	Loads a shader with the specified filename
-		 */
+		/**	Loads a shader with the specified filename */
 		HShader getShader(const WString& name) const;
 
 		HShader mShaderDockOverlay;
@@ -511,4 +445,6 @@ namespace BansheeEngine
 		static const WString EmptyShaderCodeFile;
 		static const WString EmptyCSScriptCodeFile;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdBreakPrefab.h

@@ -8,32 +8,29 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A command used for undo/redo purposes. It breaks a prefab link of a scene object
-	 *			and allows you to restore link.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/** A command used for undo/redo purposes. It breaks a prefab link of a scene object and allows you to restore link. */
 	class BS_ED_EXPORT CmdBreakPrefab : public EditorCommand
 	{
 	public:
 		~CmdBreakPrefab();
 
 		/**
-		 * @brief	Creates and executes the command on the provided scene object.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided scene object. Automatically registers the command with undo/redo
+		 * system.
 		 *
-		 * @param	sceneObject		Scene object whose prefab link to break.
-		 * @param	description		Optional description of what exactly the command does.
+		 * @param[in]	sceneObject		Scene object whose prefab link to break.
+		 * @param[in]	description		Optional description of what exactly the command does.
 		 */
 		static void execute(const HSceneObject& sceneObject, const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -41,9 +38,7 @@ namespace BansheeEngine
 
 		CmdBreakPrefab(const WString& description, const HSceneObject& sceneObject);
 
-		/**
-		 * @brief	Clears all internal cached data. Should be called whenever a change is commited.
-		 */
+		/**	Clears all internal cached data. Should be called whenever a change is commited. */
 		void clear();
 
 		HSceneObject mSceneObject;
@@ -53,4 +48,6 @@ namespace BansheeEngine
 		PrefabDiffPtr mPrefabDiff;
 		UnorderedMap<UINT64, UINT32> mLinkIds;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdCloneSO.h

@@ -9,45 +9,40 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A command used for undo/redo purposes. Clones scene object(s)
-	 *			and removes them as an undo operation.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/** A command used for undo/redo purposes. Clones scene object(s) and removes them as an undo operation. */
 	class BS_ED_EXPORT CmdCloneSO : public EditorCommand
 	{
 	public:
 		~CmdCloneSO();
 
 		/**
-		 * @brief	Creates a new scene object by cloning an existing object.
-		 *			Automatically registers the command with undo/redo system.
-		 *
-		 * @param	sceneObject		Scene object to clone.
-		 * @param	description		Optional description of what exactly the command does.
+		 * Creates a new scene object by cloning an existing object. Automatically registers the command with undo/redo 
+		 * system.
 		 *
-		 * @return	Cloned object.
+		 * @param[in]	sceneObject		Scene object to clone.
+		 * @param[in]	description		Optional description of what exactly the command does.
+		 * @return						Cloned object.
 		 */
 		static HSceneObject execute(const HSceneObject& sceneObject, const WString& description = StringUtil::WBLANK);
 
 		/**
-		 * @brief	Creates new scene object(s) by cloning existing objects.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates new scene object(s) by cloning existing objects. Automatically registers the command with undo/redo 
+		 * system.
 		 *
-		 * @param	sceneObjects	Scene object(s) to clone.
-		 * @param	description		Optional description of what exactly the command does.
-		 *
-		 * @return	Cloned objects.
+		 * @param[in]	sceneObjects	Scene object(s) to clone.
+		 * @param[in]	description		Optional description of what exactly the command does.
+		 * @return						Cloned objects.
 		 */
 		static Vector<HSceneObject> execute(const Vector<HSceneObject>& sceneObjects, const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -58,4 +53,6 @@ namespace BansheeEngine
 		Vector<HSceneObject> mOriginals;
 		Vector<HSceneObject> mClones;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdCreateSO.h

@@ -9,35 +9,30 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A command used for undo/redo purposes. Creates a scene object 
-	 *			and removes it as an undo operation.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/** A command used for undo/redo purposes. Creates a scene object and removes it as an undo operation. */
 	class BS_ED_EXPORT CmdCreateSO : public EditorCommand
 	{
 	public:
 		~CmdCreateSO();
 
 		/**
-		 * @brief	Creates a new scene object.
-		 *			Automatically registers the command with undo/redo system.
-		 *
-		 * @param	name		Name of the scene object.
-		 * @param	flags		Optional creation flags for the scene object.
-		 * @param	description	Optional description of what exactly the command does.
+		 * Creates a new scene object. Automatically registers the command with undo/redo system.
 		 *
-		 * @return	Newly created scene object.
+		 * @param[in]	name		Name of the scene object.
+		 * @param[in]	flags		Optional creation flags for the scene object.
+		 * @param[in]	description	Optional description of what exactly the command does.
+		 * @return					Newly created scene object.
 		 */
 		static HSceneObject execute(const String& name, UINT32 flags, const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -50,4 +45,6 @@ namespace BansheeEngine
 
 		HSceneObject mSceneObject;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdDeleteSO.h

@@ -9,32 +9,29 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A command used for undo/redo purposes. Deletes a scene object
-	 *			and restores it as an undo operation.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/** A command used for undo/redo purposes. Deletes a scene object and restores it as an undo operation. */
 	class BS_ED_EXPORT CmdDeleteSO : public EditorCommand
 	{
 	public:
 		~CmdDeleteSO();
 
 		/**
-		 * @brief	Creates and executes the command on the provided scene object.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided scene object. Automatically registers the command with 
+		 * undo/redo system.
 		 *
-		 * @param	sceneObject	Scene object to delete.
-		 * @param	description	Optional description of what exactly the command does.
+		 * @param[in]	sceneObject	Scene object to delete.
+		 * @param[in]	description	Optional description of what exactly the command does.
 		 */
 		static void execute(const HSceneObject& sceneObject, const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -43,15 +40,12 @@ namespace BansheeEngine
 		CmdDeleteSO(const WString& description, const HSceneObject& sceneObject);
 
 		/**
-		 * @brief	Saves the state of the specified object, all of its children
-		 *			and components. Make sure to call "clear" when you no longer need
-		 *			the data, or wish to call this method again.
+		 * Saves the state of the specified object, all of its children and components. Make sure to call clear() when you
+		 * no longer need the data, or wish to call this method again.
 		 */
 		void recordSO(const HSceneObject& sceneObject);
 
-		/**
-		 * @brief	Clears all the stored data and frees memory.
-		 */
+		/**	Clears all the stored data and frees memory. */
 		void clear();
 
 		HSceneObject mSceneObject;
@@ -61,4 +55,6 @@ namespace BansheeEngine
 		UINT32 mSerializedObjectSize;
 		UINT64 mSerializedObjectParentId;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdInputFieldValueChange.h

@@ -8,41 +8,42 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup UndoRedo
+	 *  @{
+	 */
+
 	/**
-	 * @brief	A command used for undo/redo purposes. It records a value of a GUI input field
-	 *			(specified by template type) and allows you to apply or revert a change to that field
-	 *			as needed.
+	 * A command used for undo/redo purposes. It records a value of a GUI input field (specified by template type) and
+	 * allows you to apply or revert a change to that field as needed.
 	 */
 	template <class InputFieldType, class ValueType>
 	class BS_ED_EXPORT CmdInputFieldValueChange : public EditorCommand
 	{
 	public:
 		/**
-		 * @brief	Creates and executes the command on the provided object and field.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided object and field. Automatically registers the command with
+		 * undo/redo system.
 		 *
-		 * @param	inputField	Input field to modify the value on.
-		 * @param	value		New value for the field.
-		 * @param	description	Optional description of what exactly the command does.
+		 * @param[in]	inputField	Input field to modify the value on.
+		 * @param[in]	value		New value for the field.
+		 * @param[in]	description	Optional description of what exactly the command does.
 		 */
-		static void execute(InputFieldType* inputField, const ValueType& value, const WString& description = StringUtil::WBLANK)
+		static void execute(InputFieldType* inputField, const ValueType& value, 
+			const WString& description = StringUtil::WBLANK)
 		{
-			CmdInputFieldValueChange* command = new (bs_alloc<CmdInputFieldValueChange>()) CmdInputFieldValueChange(description, inputField, value);
+			CmdInputFieldValueChange* command = 
+				new (bs_alloc<CmdInputFieldValueChange>()) CmdInputFieldValueChange(description, inputField, value);
 			UndoRedo::instance().registerCommand(command);
 			command->commit();
 		}
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override
 		{
 			mInputField->_setValue(mNewValue, true);
 		}
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override
 		{
 			mInputField->_setValue(mOldValue, true);
@@ -59,4 +60,6 @@ namespace BansheeEngine
 		ValueType mNewValue;
 		InputFieldType* mInputField;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdInstantiateSO.h

@@ -9,9 +9,13 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A command used for undo/redo purposes. Instantiates scene object(s)
-	 *			from a prefab and removes them as an undo operation.
+	/** @addtogroup UndoRedo
+	 *  @{
+	 */
+
+	/**	
+	 * A command used for undo/redo purposes. Instantiates scene object(s) from a prefab and removes them as an undo
+	 * operation.
 	 */
 	class BS_ED_EXPORT CmdInstantiateSO : public EditorCommand
 	{
@@ -19,24 +23,18 @@ namespace BansheeEngine
 		~CmdInstantiateSO();
 
 		/**
-		 * @brief	Instantiates the specified prefab.
-		 *			Automatically registers the command with undo/redo system.
+		 * Instantiates the specified prefab. Automatically registers the command with undo/redo system.
 		 *
-		 * @param	prefab			Prefab to instantiate.
-		 * @param	description		Optional description of what exactly the command does.
-		 *
-		 * @return	Instantiated object.
+		 * @param[in]	prefab			Prefab to instantiate.
+		 * @param[in]	description		Optional description of what exactly the command does.
+		 * @return						Instantiated object.
 		 */
 		static HSceneObject execute(const HPrefab& prefab, const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -47,4 +45,6 @@ namespace BansheeEngine
 		HPrefab mPrefab;
 		HSceneObject mSceneObject;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdRecordSO.h

@@ -9,10 +9,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup UndoRedo
+	 *  @{
+	 */
+
 	/**
-	 * @brief	A command used for undo/redo purposes. It records a state of the entire
-	 *			scene object at a specific point and allows you to restore it to its
-	 *			original values as needed.
+	 * A command used for undo/redo purposes. It records a state of the entire scene object at a specific point and allows
+	 * you to restore it to its original values as needed.
 	 */
 	class BS_ED_EXPORT CmdRecordSO : public EditorCommand
 	{
@@ -20,24 +23,20 @@ namespace BansheeEngine
 		~CmdRecordSO();
 
 		/**
-		 * @brief	Creates and executes the command on the provided scene object.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided scene object. Automatically registers the command with undo/redo
+		 * system.
 		 *
-		 * @param	sceneObject		Scene object to record.
-		 * @param	recordHierarchy	If true, all children of the provided scene object will be recorded as well.
-		 * @param	description		Optional description of what exactly the command does.
+		 * @param[in]	sceneObject		Scene object to record.
+		 * @param[in]	recordHierarchy	If true, all children of the provided scene object will be recorded as well.
+		 * @param[in]	description		Optional description of what exactly the command does.
 		 */
 		static void execute(const HSceneObject& sceneObject, bool recordHierarchy = false, 
 			const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -46,15 +45,12 @@ namespace BansheeEngine
 		CmdRecordSO(const WString& description, const HSceneObject& sceneObject, bool recordHierarchy);
 
 		/**
-		 * @brief	Saves the state of the specified object, all of its children
-		 *			and components. Make sure to call "clear" when you no longer need
-		 *			the data, or wish to call this method again.
+		 * Saves the state of the specified object, all of its children and components. Make sure to call clear() when you
+		 * no longer need the data, or wish to call this method again.
 		 */
 		void recordSO(const HSceneObject& sceneObject);
 
-		/**
-		 * @brief	Clears all the stored data and frees memory.
-		 */
+		/**	Clears all the stored data and frees memory. */
 		void clear();
 
 		HSceneObject mSceneObject;
@@ -64,4 +60,6 @@ namespace BansheeEngine
 		UINT8* mSerializedObject;
 		UINT32 mSerializedObjectSize;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdReparentSO.h

@@ -8,44 +8,43 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup UndoRedo
+	 *  @{
+	 */
+
 	/**
-	 * @brief	A command used for undo/redo purposes. It records a scene object
-	 *			parent change operations. It allows you to apply the parent change
-	 *			or revert the object to its original parent as needed.
+	 * A command used for undo/redo purposes. It records a scene object parent change operations. It allows you to apply
+	 * the parent change or revert the object to its original parent as needed.
 	 */
 	class BS_ED_EXPORT CmdReparentSO : public EditorCommand
 	{
 	public:
 		/**
-		 * @brief	Creates and executes the command on the provided scene object(s).
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided scene object(s). Automatically registers the command with
+		 * undo/redo system.
 		 *
-		 * @param	sceneObjects	Object(s) to change the parent for.
-		 * @param	newParent		New parent for the provided objects.
-		 * @param	description		Optional description of what exactly the command does.
+		 * @param[in]	sceneObjects	Object(s) to change the parent for.
+		 * @param[in]	newParent		New parent for the provided objects.
+		 * @param[in]	description		Optional description of what exactly the command does.
 		 */
 		static void execute(const Vector<HSceneObject>& sceneObjects, const HSceneObject& newParent, 
 			const WString& description = StringUtil::WBLANK);
 
 		/**
-		 * @brief	Creates and executes the command on the provided scene object.
-		 *			Automatically registers the command with undo/redo system.
+		 * Creates and executes the command on the provided scene object. Automatically registers the command with
+		 * undo/redo system.
 		 *
-		 * @param	sceneObject		Object to change the parent for.
-		 * @param	newParent		New parent for the provided objects.
-		 * @param	description		Optional description of what exactly the command does.
+		 * @param[in]	sceneObject		Object to change the parent for.
+		 * @param[in]	newParent		New parent for the provided objects.
+		 * @param[in]	description		Optional description of what exactly the command does.
 		 */
 		static void execute(HSceneObject& sceneObject, const HSceneObject& newParent, 
 			const WString& description = StringUtil::WBLANK);
 
-		/**
-		 * @copydoc	EditorCommand::commit
-		 */
+		/** @copydoc EditorCommand::commit */
 		void commit() override;
 
-		/**
-		 * @copydoc	EditorCommand::revert
-		 */
+		/** @copydoc EditorCommand::revert */
 		void revert() override;
 
 	private:
@@ -57,4 +56,6 @@ namespace BansheeEngine
 		Vector<HSceneObject> mOldParents;
 		HSceneObject mNewParent;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsCmdUtility.h

@@ -6,19 +6,22 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains various utility methods and structures used by EditorCommand%s.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/** Contains various utility methods and structures used by EditorCommand%s. */
 	class CmdUtility
 	{
 	public:
 		/**
-		 * @brief	Contains stored information about stored scene object instance data,
-		 *			including all of its children and components.
+		 * Contains stored information about stored scene object instance data, including all of its children and
+		 * components.
 		 *
-		 * @note	When object is serialized it will receive new instance data (as if it was a new
-		 *			object). But we want to restore the original object completely (including any references
-		 *			other objects might have to it) so we need store the instance data.
+		 * @note	
+		 * When object is serialized it will receive new instance data (as if it was a new object). But we want to restore
+		 * the original object completely (including any references	other objects might have to it) so we need store the
+		 * instance data.
 		 */
 		struct SceneObjProxy
 		{
@@ -29,19 +32,20 @@ namespace BansheeEngine
 		};
 
 		/**
-		 * @brief	Parses the scene object hierarchy and components and generates a
-		 *			hierarchy of instance data required to restore the object identities.
+		 * Parses the scene object hierarchy and components and generates a hierarchy of instance data required to restore
+		 * the object identities.
 		 */
 		static SceneObjProxy createProxy(const HSceneObject& sceneObject);
 
 		/**
-		 * @brief	Restores original object instance data from the provided scene object proxy
-		 *			that was previously generated using ::createProxy.
+		 * Restores original object instance data from the provided scene object proxy that was previously generated using
+		 * createProxy().
 		 *
-		 * @param	restored	New instance of the object.
-		 * @param	proxy		Proxy data containing the original object instance data
-		 *						we want to restore.
+		 * @param[in]	restored	New instance of the object.
+		 * @param[in]	proxy		Proxy data containing the original object instance data we want to restore.
 		 */
 		static void restoreIds(const HSceneObject& restored, SceneObjProxy& proxy);
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsEditorApplication.h

@@ -7,6 +7,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Application-Editor
+	 *  @{
+	 */
+
 	/**	Types of render APIs supported by the editor. */
 	enum class EditorRenderAPI
 	{
@@ -145,4 +149,6 @@ namespace BansheeEngine
 
 	/**	Easy way to access EditorApplication. */
 	BS_ED_EXPORT EditorApplication& gEditorApplication();
+
+	/** @} */
 }

BansheeEditor/Include/BsEditorCommand.h

@@ -6,9 +6,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup UndoRedo
+	 *  @{
+	 */
+
 	/**
-	 * @brief	A command used for undo/redo purposes. It records a change occurring on
-	 *			some object and allows you to apply or revert that change as needed.
+	 * A command used for undo/redo purposes. It records a change occurring on some object and allows you to apply or
+	 * revert that change as needed.
 	 */
 	class BS_ED_EXPORT EditorCommand
 	{
@@ -16,20 +20,13 @@ namespace BansheeEngine
 		EditorCommand(const WString& description);
 		virtual ~EditorCommand() { }
 
-		/**
-		 * @brief	Applies the command, committing the change.
-		 */
+		/**	Applies the command, committing the change. */
 		virtual void commit() { }
 
-		/**
-		 * @brief	Reverts the command, reverting the change previously
-		 *			done with "commit".
-		 */
+		/** Reverts the command, reverting the change previously done with commit(). */
 		virtual void revert() { }
 
-		/**
-		 * @brief	Deletes the command.
-		 */
+		/**	Deletes the command. */
 		static void destroy(EditorCommand* command);
 
 	private:
@@ -38,4 +35,6 @@ namespace BansheeEngine
 		WString mDescription;
 		UINT32 mId;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsEditorPrerequisites.h

@@ -57,6 +57,10 @@
  *  Provides functionality for undoing and redoing actions within the editor.
  */
 
+/** @defgroup Application-Editor Application
+ *  Entry point into the editor application.
+ */
+
 /** @} */
 
 #if (BS_PLATFORM == BS_PLATFORM_WIN32) && !defined(__MINGW32__)

BansheeEditor/Include/BsEditorSettings.h

@@ -8,6 +8,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Settings
+	 *  @{
+	 */
+
 	struct RecentProject;
 
 	/**	Contains various globally accessible editor preferences. */
@@ -151,4 +155,6 @@ namespace BansheeEngine
 		Path path;
 		UINT64 accessTimestamp;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsEditorTestSuite.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Testing-Editor
+	 *  @{
+	 */
+	/** @cond INTERNAL */
+
 	class TestComponentA : public Component
 	{
 	public:
@@ -29,7 +34,7 @@ namespace BansheeEngine
 	public:
 		friend class TestComponentARTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		RTTITypeBase* getRTTI() const override;
 
 	protected:
 		TestComponentA() {} // Serialization only
@@ -56,46 +61,36 @@ namespace BansheeEngine
 	public:
 		friend class TestComponentBRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		RTTITypeBase* getRTTI() const override;
 
 	protected:
 		TestComponentB() {} // Serialization only
 	};
 
-	/**
-	 * @brief	Contains a set of unit tests for the editor.
-	 */
+	/** @endcond */
+
+	/**	Contains a set of unit tests for the editor. */
 	class EditorTestSuite : public TestSuite
 	{
 	public:
 		EditorTestSuite();
 
 	private:
-		/**
-		 * @brief	Tests SceneObject record undo/redo operation.
-		 */
+		/**	Tests SceneObject record undo/redo operation. */
 		void SceneObjectRecord_UndoRedo();
 
-		/**
-		 * @brief	Tests SceneObject delete undo/redo operation.
-		 */
+		/**	Tests SceneObject delete undo/redo operation. */
 		void SceneObjectDelete_UndoRedo();
 
-		/**
-		 * @brief	Tests native diff by modifiying an object, generating a diff
-		 *			and re-applying the modifications.
-		 */
+		/** Tests native diff by modifiying an object, generating a diff and re-applying the modifications. */
 		void BinaryDiff();
 
-		/**
-		 * @brief	Tests prefab diff by modifiying a prefab, generating a diff
-		 *			and re-applying the modifications.
-		 */
+		/** Tests prefab diff by modifiying a prefab, generating a diff and re-applying the modifications. */
 		void TestPrefabDiff();
 
-		/**
-		 * @brief	Tests the frame allocator.
-		 */
+		/**	Tests the frame allocator. */
 		void TestFrameAlloc();
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsEditorUtility.h

@@ -7,34 +7,36 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains miscelanous helper methods.
+	/** @addtogroup Utility-Editor
+	 *  @{
 	 */
+
+	/**	Contains miscellaneous helper methods. */
 	class BS_ED_EXPORT EditorUtility
 	{
 	public:
 		/**
-		 * @brief	Calculates world space bounds of the specified scene object. This will
-		 *			consider components with bounds like Renderable.
+		 * Calculates world space bounds of the specified scene object. This will consider components with bounds like
+		 * Renderable.
 		 */
 		static AABox calculateBounds(const HSceneObject& object);
 
 		/**
-		 * @brief	Calculates world space bounds of the specified scene objects. This will
-		 *			consider components with bounds like Renderable.
+		 * Calculates world space bounds of the specified scene objects. This will consider components with bounds like
+		 * Renderable.
 		 */
 		static AABox calculateBounds(const Vector<HSceneObject>& objects);
 
 	private:
 		/**
-		 * @brief	Retrieves all components containing meshes on the specified object and outputs
-		 *			their bounds.
-		 *
-		 * @param	object	Object to calculate bounds for.
-		 * @param	bounds	Output bounds, if successful.
+		 * Retrieves all components containing meshes on the specified object and outputs their bounds.
 		 *
-		 * @returns true if a mesh component was found, otherwise false (bounds will not be updated).
+		 * @param[in]	object	Object to calculate bounds for.
+		 * @param[in]	bounds	Output bounds, if successful.
+		 * @return				True if a mesh component was found, otherwise false (bounds will not be updated).
 		 */
 		static bool calculateMeshBounds(const HSceneObject& object, AABox& bounds);
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsProjectSettings.h

@@ -7,22 +7,20 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains various globally accessible project-specific preferences.
+	/** @addtogroup Settings
+	 *  @{
 	 */
+
+	/**	Contains various globally accessible project-specific preferences. */
 	class BS_ED_EXPORT ProjectSettings : public Settings
 	{
 	public:
 		ProjectSettings();
 
-		/**
-		 * @brief	Retrieves the UUID of the last scene open in the editor.
-		 */
+		/**	Retrieves the UUID of the last scene open in the editor. */
 		String getLastOpenScene() const { return mLastOpenScene; }
 
-		/**
-		 * @brief	Sets the UUID of the last scene open in the editor.
-		 */
+		/**	Sets the UUID of the last scene open in the editor. */
 		void setLastOpenScene(const String& value) { mLastOpenScene = value; markAsDirty(); }
 
 	private:
@@ -36,4 +34,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsSceneGrid.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Scene-Editor
+	 *  @{
+	 */
+
 	class SceneGridCore;
 
 	/** Determines how is the scene grid drawn. */
@@ -129,4 +134,7 @@ namespace BansheeEngine
 		static const float FADE_OUT_START;
 		static const float FADE_OUT_END;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEditor/Include/BsScenePicking.h

@@ -9,16 +9,16 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Scene-Editor
+	 *  @{
+	 */
+
 	class ScenePickingCore;
 
-	/**
-	 * @brief	Handles picking of scene objects with a pointer in scene view.
-	 */
+	/**	Handles picking of scene objects with a pointer in scene view. */
 	class BS_ED_EXPORT ScenePicking : public Module<ScenePicking>
 	{
-		/**
-		 * @brief	Contains information about a single pickable item (mesh).
-		 */
+		/**	Contains information about a single pickable item (mesh). */
 		struct RenderablePickData
 		{
 			SPtr<MeshCore> mesh;
@@ -34,28 +34,25 @@ namespace BansheeEngine
 		~ScenePicking();
 
 		/**
-		 * @brief	Attempts to find a single nearest scene object under the provided position and area.
-		 *
-		 * @param	cam			Camera to perform the picking from.
-		 * @param	position	Pointer position relative to the camera viewport, in pixels.
-		 * @param	area		Width/height of the checked area in pixels. Use (1, 1) if you want the
-		 *						exact position under the pointer.
+		 * Attempts to find a single nearest scene object under the provided position and area.
 		 *
-		 * @return	Nearest SceneObject under the provided area, or an empty handle if no object is found.
+		 * @param[in]	cam			Camera to perform the picking from.
+		 * @param[in]	position	Pointer position relative to the camera viewport, in pixels.
+		 * @param[in]	area		Width/height of the checked area in pixels. Use (1, 1) if you want the exact position
+		 *							under the pointer.
+		 * @return					Nearest SceneObject under the provided area, or an empty handle if no object is found.
 		 */
 		HSceneObject pickClosestObject(const CameraPtr& cam, const Vector2I& position, const Vector2I& area);
 
-
 		/**
-		 * @brief	Attempts to find all scene objects under the provided position and area. This does not mean
-		 *			objects occluded by other objects.
-		 *
-		 * @param	cam			Camera to perform the picking from.
-		 * @param	position	Pointer position relative to the camera viewport, in pixels.
-		 * @param	area		Width/height of the checked area in pixels. Use (1, 1) if you want the
-		 *						exact position under the pointer.
+		 * Attempts to find all scene objects under the provided position and area. This does not mean objects occluded by
+		 * other objects.
 		 *
-		 * @return	A list of SceneObject%s under the provided area.
+		 * @param[in]	cam			Camera to perform the picking from.
+		 * @param[in]	position	Pointer position relative to the camera viewport, in pixels.
+		 * @param[in]	area		Width/height of the checked area in pixels. Use (1, 1) if you want the exact position
+		 *							under the pointer.
+		 * @return					A list of SceneObject%s under the provided area.
 		 */
 		Vector<HSceneObject> pickObjects(const CameraPtr& cam, const Vector2I& position, const Vector2I& area);
 
@@ -64,30 +61,21 @@ namespace BansheeEngine
 
 		typedef Set<RenderablePickData, std::function<bool(const RenderablePickData&, const RenderablePickData&)>> RenderableSet;
 
-		/**
-		 * @brief	Encodes a pickable object identifier to a unique color.
-		 */
+		/**	Encodes a pickable object identifier to a unique color. */
 		static Color encodeIndex(UINT32 index);
 
-		/**
-		 * @brief	Decodes a color into a unique object identifier. Color should
-		 *			have initially been encoded with ::encodeIndex.
-		 */
+		/** Decodes a color into a unique object identifier. Color should have initially been encoded with encodeIndex(). */
 		static UINT32 decodeIndex(Color color);
 
 		ScenePickingCore* mCore;
 	};
 
-	/**
-	 * @brief	Core thread version of the ScenePicking manager. Handles
-	 *			actual rendering.
-	 */
+	/** @cond INTERNAL */
+
+	/** Core thread version of the ScenePicking manager. Handles actual rendering. */
 	class ScenePickingCore
 	{
-		/**
-		 * @brief	A list of materials and their parameters to be used for rendering
-		 *			of pickable objects.
-		 */
+		/** A list of materials and their parameters to be used for rendering of pickable objects. */
 		struct MaterialData
 		{
 			SPtr<MaterialCore> mMatPickingCore;
@@ -106,41 +94,36 @@ namespace BansheeEngine
 		};
 
 	public:
-		/**
-		 * @brief	Initializes the manager. Must be called right after construction.
-		 */
+		/**	Initializes the manager. Must be called right after construction. */
 		void initialize();
 
-		/**
-		 * @brief	Destroys the manager. Must be called right before destruction.
-		 */
+		/**	Destroys the manager. Must be called right before destruction. */
 		void destroy();
 
 		/**
-		 * @brief	Sets up the viewport, materials and their parameters as needed for picking. Also renders
-		 *			all the provided renderable objects. Must be followed by ::corePickingEnd. You may call other methods
-		 *			after this one, but you must ensure they render proper unique pickable colors that can be resolved
-		 *			to SceneObject%s later.
+		 * Sets up the viewport, materials and their parameters as needed for picking. Also renders all the provided
+		 * renderable objects. Must be followed by corePickingEnd(). You may call other methods after this one, but you must
+		 * ensure they render proper unique pickable colors that can be resolved to SceneObject%s later.
 		 *
-		 * @param	target			Render target to render to.
-		 * @param	viewportArea	Normalized area of the render target to render in.
-		 * @param	renderables		A set of pickable Renderable objects to render.
-		 * @param	position		Position of the pointer where to pick objects, in pixels relative to viewport.
-		 * @param	area			Width/height of the area to pick objects, in pixels.
+		 * @param[in]	target			Render target to render to.
+		 * @param[in]	viewportArea	Normalized area of the render target to render in.
+		 * @param[in]	renderables		A set of pickable Renderable objects to render.
+		 * @param[in]	position		Position of the pointer where to pick objects, in pixels relative to viewport.
+		 * @param[in]	area			Width/height of the area to pick objects, in pixels.
 		 */
-		void corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const ScenePicking::RenderableSet& renderables,
-			const Vector2I& position, const Vector2I& area);
+		void corePickingBegin(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, 
+			const ScenePicking::RenderableSet& renderables, const Vector2I& position, const Vector2I& area);
 		
 		/**
-		 * @brief	Ends picking operation started by ::corePickingBegin. Render target is resolved and objects in the picked area
-		 *			are returned.
+		 * Ends picking operation started by ::corePickingBegin. Render target is resolved and objects in the picked area
+		 * are returned.
 		 *
-		 * @param	target			Render target we're rendering to.
-		 * @param	viewportArea	Normalized area of the render target we're rendering in.
-		 * @param	position		Position of the pointer where to pick objects, in pixels relative to viewport.
-		 * @param	area			Width/height of the area to pick objects, in pixels.
-		 * @param	asyncOp			Async operation handle that when complete will contain the results of the picking
-		 *							operation in the form of Vector<SelectedObject>.
+		 * @param[in]	target			Render target we're rendering to.
+		 * @param[in]	viewportArea	Normalized area of the render target we're rendering in.
+		 * @param[in]	position		Position of the pointer where to pick objects, in pixels relative to viewport.
+		 * @param[in]	area			Width/height of the area to pick objects, in pixels.
+		 * @param[out]	asyncOp			Async operation handle that when complete will contain the results of the picking
+		 *								operation in the form of Vector<SelectedObject>.
 		 */
 		void corePickingEnd(const SPtr<RenderTargetCore>& target, const Rect2& viewportArea, const Vector2I& position,
 			const Vector2I& area, AsyncOp& asyncOp);
@@ -152,4 +135,7 @@ namespace BansheeEngine
 
 		MaterialData mMaterialData[3];
 	};
+
+	/** @endcond */
+	/** @} */
 }

BansheeEditor/Include/BsSelection.h

@@ -7,9 +7,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Scene-Editor
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Handles scene object and resource selection. Triggeres events when selection changes and allows the 
-	 *			user to query current selection state.
+	 * Handles scene object and resource selection. Triggeres events when selection changes and allows the user to query
+	 * current selection state.
 	 */
 	class BS_ED_EXPORT Selection : public Module<Selection>
 	{
@@ -17,89 +21,65 @@ namespace BansheeEngine
 		Selection();
 		~Selection();
 
-		/**
-		 * @brief	Returns a currently selected set of scene objects.
-		 */
+		/**	Returns a currently selected set of scene objects. */
 		const Vector<HSceneObject>& getSceneObjects() const;
 
-		/**
-		 * @brief	Sets a new set of scene objects to select, replacing the old ones.
-		 */
+		/**	Sets a new set of scene objects to select, replacing the old ones. */
 		void setSceneObjects(const Vector<HSceneObject>& sceneObjects);
 
-		/**
-		 * @brief	Returns a currently selected set of resource paths.
-		 */
+		/**	Returns a currently selected set of resource paths. */
 		const Vector<Path>& getResourcePaths() const;
 
-		/**
-		 * @brief	Sets a new set of resource paths to select, replacing the old ones.
-		 */
+		/**	Sets a new set of resource paths to select, replacing the old ones. */
 		void setResourcePaths(const Vector<Path>& paths);
 
-		/**
-		 * @brief	Returns a currently selected set of resource UUIDs.
-		 */
+		/**	Returns a currently selected set of resource UUIDs. */
 		Vector<String> getResourceUUIDs() const;
 
-		/**
-		 * @brief	Sets a new set of resource UUIDs to select, replacing the old ones.
-		 */
+		/**	Sets a new set of resource UUIDs to select, replacing the old ones. */
 		void setResourceUUIDs(const Vector<String>& UUIDs);
 
-		/**
-		 * @brief	Deselects all currently selected scene objects.
-		 */
+		/**	Deselects all currently selected scene objects. */
 		void clearSceneSelection();
 
-		/**
-		 * @brief	Deselects all currently selected resources.
-		 */
+		/**	Deselects all currently selected resources. */
 		void clearResourceSelection();
 
-		/**
-		 * @brief	Pings the scene object, highlighting it in its respective editors.
-		 */
+		/**	Pings the scene object, highlighting it in its respective editors. */
 		void ping(const HSceneObject& sceneObject);
 
 		/**
-		 * @brief	Pings the resource, highlighting it in its respective editors.
+		 * Pings the resource, highlighting it in its respective editors.
 		 * 		
-		 * @param	resourcePath	Resource path relative to the project library resources folder.
+		 * @param[in]	resourcePath	Resource path relative to the project library resources folder.
 		 */
 		void ping(const Path& resourcePath);
 
 		/**
-		 * @brief	Triggered whenever scene object or resource selection changes. The provided
-		 *			parameters will contain the newly selected objects/resource paths.
+		 * Triggered whenever scene object or resource selection changes. The provided parameters will contain the newly
+		 * selected objects/resource paths.
 		 */
 		Event<void(const Vector<HSceneObject>&, const Vector<Path>&)> onSelectionChanged; 
 
 		/**
-		 * @brief	Triggered when a scene object ping is requested. Ping usually means the
-		 *			object will be highlighted in its respective editors.
+		 * Triggered when a scene object ping is requested. Ping usually means the object will be highlighted in its
+		 * respective editors.
 		 */
 		Event<void(const HSceneObject&)> onSceneObjectPing; 
 
 		/**
-		 * @brief	Triggered when a resource ping is requested. Ping usually means the
-		 *			object will be highlighted in its respective editors.
+		 * Triggered when a resource ping is requested. Ping usually means the object will be highlighted in its respective
+		 * editors.
 		 */
 		Event<void(const Path&)> onResourcePing; 
 	private:
-		/**
-		 * @brief	Triggered when the scene object selection in the scene tree view changes.
-		 */
+		/**	Triggered when the scene object selection in the scene tree view changes. */
 		void sceneSelectionChanged();
 
-		/**
-		 * @brief	Triggered when the resource selection in the resource tree view changes.
-		 */
+		/**	Triggered when the resource selection in the resource tree view changes. */
 		void resourceSelectionChanged();
 
-		/**
-		 * @brief	Updates scene and resource tree views with new selection.
-		 */
+		/**	Updates scene and resource tree views with new selection. */
 		void updateTreeViews();
 
 		Vector<HSceneObject> mSelectedSceneObjects;
@@ -108,4 +88,6 @@ namespace BansheeEngine
 		HMessage mSceneSelectionChangedConn;
 		HMessage mResourceSelectionChangedConn;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsSelectionRenderer.h

@@ -9,16 +9,17 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Scene-Editor
+	 *  @{
+	 */
+
 	class SelectionRendererCore;
 
-	/**
-	 * @brief	Handles rendering of the selected SceneObject%s overlay.
-	 */
+	/**	Handles rendering of the selected SceneObject%s overlay. */
 	class BS_ED_EXPORT SelectionRenderer
 	{
-		/**
-		 * @brief	Contains data about a selected mesh.
-		 */
+		/**	Contains data about a selected mesh. */
 		struct ObjectData
 		{
 			SPtr<MeshCoreBase> mesh;
@@ -29,37 +30,30 @@ namespace BansheeEngine
 		SelectionRenderer();
 		~SelectionRenderer();
 
-		/**
-		 * @brief	Called once per frame. Updates the overlay depending on current selection.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Called once per frame. Updates the overlay depending on current selection. */
 		void update(const CameraPtr& camera);
 
 	private:
 		friend class SelectionRendererCore;
 
 		/**
-		 * @brief	Initializes the core thread counterpart of the selection renderer.
+		 * Initializes the core thread counterpart of the selection renderer.
 		 *
-		 * @param	mat	Material used for selection rendering.
+		 * @param[in]	mat		Material used for selection rendering.
 		 */
 		void initializeCore(const SPtr<MaterialCore>& mat);
 
 		/**
-		 * @brief	Destroys the core thread counterpart of the selection renderer.
+		 * Destroys the core thread counterpart of the selection renderer.
 		 *
-		 * @param	core	Previously constructed core thread selection renderer instance.
+		 * @param[in]	core	Previously constructed core thread selection renderer instance.
 		 */
 		void destroyCore(SelectionRendererCore* core);
 
 		std::atomic<SelectionRendererCore*> mCore;
 	};
 
-	/**
-	 * @brief	Core thread version of the selection renderer, that handles
-	 *			actual rendering.
-	 */
+	/** Core thread version of the selection renderer, that handles actual rendering. */
 	class SelectionRendererCore
 	{
 		friend class SelectionRenderer;
@@ -72,24 +66,20 @@ namespace BansheeEngine
 
 	private:
 		/**
-		 * @brief	Initializes the selection renderer. Should be called right
-		 *			after construction.
+		 * Initializes the selection renderer. Should be called right after construction.
 		 *
-		 * @param	mat	Material used for selection rendering.
+		 * @param[in]	mat	Material used for selection rendering.
 		 */
 		void initialize(const SPtr<MaterialCore>& mat);
 
-		/**
-		 * @brief	Triggered by the Renderer when the overlay should be rendered.
-		 */
+		/** Triggered by the Renderer when the overlay should be rendered. */
 		void render();
 
 		/**
-		 * @brief	Updates the internal data that determines what will be rendered on the next
-		 *			::render call.
+		 * Updates the internal data that determines what will be rendered on the next render() call.
 		 *
-		 * @param	camera	Camera to render the selection overlay in.
-		 * @param	objects	A set of objects to render with the selection overlay.
+		 * @param[in]	camera		Camera to render the selection overlay in.
+		 * @param[in]	objects		A set of objects to render with the selection overlay.
 		 */
 		void updateData(const SPtr<CameraCore>& camera, const Vector<SelectionRenderer::ObjectData>& objects);
 
@@ -103,4 +93,7 @@ namespace BansheeEngine
 
 		static const Color SELECTION_COLOR;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEditor/Include/BsSettings.h

@@ -7,83 +7,54 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains a serializable set of generic key-value pairs.
+	/** @addtogroup Settings
+	 *  @{
 	 */
+
+	/**	Contains a serializable set of generic key-value pairs. */
 	class BS_ED_EXPORT Settings : public IReflectable
 	{
 	public:
 		Settings();
 
-		/**
-		 * @brief	Adds or updates a property key/value pair with a floating point value.
-		 */
+		/**	Adds or updates a property key/value pair with a floating point value. */
 		void setFloat(const String& name, float value);
 
-		/**
-		 * @brief	Adds or updates a property key/value pair with a signed integer value.
-		 */
+		/**	Adds or updates a property key/value pair with a signed integer value. */
 		void setInt(const String& name, INT32 value);
 
-		/**
-		 * @brief	Adds or updates a property key/value pair with a boolean value.
-		 */
+		/**	Adds or updates a property key/value pair with a boolean value. */
 		void setBool(const String& name, bool value);
 
-		/**
-		 * @brief	Adds or updates a property key/value pair with a string value.
-		 */
+		/**	Adds or updates a property key/value pair with a string value. */
 		void setString(const String& name, const WString& value);
 
-		/**
-		 * @brief	Returns the floating point value of the specified key, or the default value
-		 *			if such key cannot be found.
-		 */
+		/** Returns the floating point value of the specified key, or the default value if such key cannot be found. */
 		float getFloat(const String& name, float defaultValue = 0.0f);
 
-		/**
-		 * @brief	Returns the integer point value of the specified key, or the default value
-		 *			if such key cannot be found.
-		 */
+		/** Returns the integer point value of the specified key, or the default value if such key cannot be found. */
 		INT32 getInt(const String& name, INT32 defaultValue = 0);
 
-		/**
-		 * @brief	Returns the boolean point value of the specified key, or the default value
-		 *			if such key cannot be found.
-		 */
+		/** Returns the boolean point value of the specified key, or the default value if such key cannot be found. */
 		bool getBool(const String& name, bool defaultValue = false);
 
-		/**
-		 * @brief	Returns the string point value of the specified key, or the default value
-		 *			if such key cannot be found.
-		 */
+		/** Returns the string point value of the specified key, or the default value if such key cannot be found. */
 		WString getString(const String& name, const WString& defaultValue = StringUtil::WBLANK);
 
-		/**
-		 * @brief	Returns true if the key with the specified name exists.
-		 */
+		/**	Returns true if the key with the specified name exists. */
 		bool hasKey(const String& name);
 
-		/**
-		 * @brief	Deletes a key with the specified name.
-		 */
+		/**	Deletes a key with the specified name. */
 		void deleteKey(const String& name);
 
-		/**
-		 * @brief	Deletes all key/value pairs.
-		 */
+		/**	Deletes all key/value pairs. */
 		void deleteAllKeys();
 
-		/**
-		 * @brief	Returns a hash value that may be used for checking if any internal settings were
-		 *			modified.
-		 */
+		/**	Returns a hash value that may be used for checking if any internal settings were modified. */
 		UINT32 getHash() const { return mHash; }
 
 	protected:
-		/**
-		 * @brief	Marks the object as dirty so that outside objects know when to update.
-		 */
+		/**	Marks the object as dirty so that outside objects know when to update. */
 		void markAsDirty() const { mHash++; }
 
 		Map<String, float> mFloatProperties;
@@ -101,4 +72,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEditor/Include/BsUndoRedo.h

@@ -7,14 +7,15 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Provides functionality to undo or redo recently performed operations in the editor.
+	/** @addtogroup UndoRedo
+	 *  @{
 	 */
+
+	/**	Provides functionality to undo or redo recently performed operations in the editor. */
 	class BS_ED_EXPORT UndoRedo : public Module<UndoRedo>
 	{
 		/**
-		 * @brief	Contains data about a single undo/redo group.
-		 *			Groups allow you to create context sensitive undo/redo operations.
+		 * Contains data about a single undo/redo group. Groups allow you to create context sensitive undo/redo operations.
 		 */
 		struct GroupData
 		{
@@ -26,78 +27,58 @@ namespace BansheeEngine
 		UndoRedo();
 		~UndoRedo();
 
-		/**
-		 * @brief	Executes the last command on the undo stack, undoing its operations.
-		 */
+		/**	Executes the last command on the undo stack, undoing its operations. */
 		void undo();
 
-		/**
-		 * @brief	Executes the last command on the redo stack (last command we called undo on), 
-		 *			re-applying its operation.
-		 */
+		/** Executes the last command on the redo stack (last command we called undo on), re-applying its operation. */
 		void redo();
 
 		/**
-		 * @brief	Creates a new undo/redo group. All new commands will be registered to this group.
-		 *			You may remove the group and all of its commands by calling ::popGroup.
+		 * Creates a new undo/redo group. All new commands will be registered to this group. You may remove the group and 
+		 * all of its commands by calling popGroup().
 		 *
-		 *			For example you might require global editor-wide undo/redo operations, and also
-		 *			more specific ones like input in an input box. When the user is done with the input
-		 *			box you no longer require its undo operations and you may use groups to easily
-		 *			remove them.
+		 * For example you might require global editor-wide undo/redo operations, and also more specific ones like input in
+		 * an input box. When the user is done with the input box you no longer require its undo operations and you may use
+		 * groups to easily remove them.
 		 *
-		 * @param	name	Unique name for the group.
+		 * @param[in]	name	Unique name for the group.
 		 */
 		void pushGroup(const String& name);
 
 		/**
-		 * @brief	Removes all the command registered to the current undo/redo group.
+		 * Removes all the command registered to the current undo/redo group.
 		 *
-		 * @param	name	Unique name for the group.
+		 * @param[in]	name	Unique name for the group.
 		 */
 		void popGroup(const String& name);
 
-		/**
-		 * @brief	Registers a new undo command.
-		 */
+		/**	Registers a new undo command. */
 		void registerCommand(EditorCommand* command);
 
-		/**
-		 * @brief	Returns the unique identifier for the command on top of the undo stack.
-		 */
+		/**	Returns the unique identifier for the command on top of the undo stack. */
 		UINT32 getTopCommandId() const;
 
 		/**
-		 * @brief	Removes a command from the undo/redo list, without executing it.
+		 * Removes a command from the undo/redo list, without executing it.
 		 *
-		 * @param	id	Identifier of the command returned by ::getTopCommandIdx.
+		 * @param[in]	id	Identifier of the command returned by ::getTopCommandIdx.
 		 */
 		void popCommand(UINT32 id);
 
-		/**
-		 * @brief	Resets the undo/redo stacks.
-		 */
+		/**	Resets the undo/redo stacks. */
 		void clear();
 
 	private:
-		/**
-		 * @brief	Removes the last undo command from the undo stack, and returns it.
-		 */
+		/**	Removes the last undo command from the undo stack, and returns it. */
 		EditorCommand* removeLastFromUndoStack();
 
-		/**
-		 * @brief	Adds a new command to the undo stack.
-		 */
+		/**	Adds a new command to the undo stack. */
 		void addToUndoStack(EditorCommand* command);
 
-		/**
-		 * @brief	Removes all entries from the undo stack.
-		 */
+		/**	Removes all entries from the undo stack. */
 		void clearUndoStack();
 
-		/**
-		 * @brief	Removes all entries from the redo stack.
-		 */
+		/**	Removes all entries from the redo stack. */
 		void clearRedoStack();
 
 		static const UINT32 MAX_STACK_ELEMENTS;
@@ -115,4 +96,6 @@ namespace BansheeEngine
 
 		Stack<GroupData> mGroups;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsApplication.h

@@ -8,7 +8,6 @@
 
 namespace BansheeEngine
 {
-	/** @cond INTERNAL */
 	/** @addtogroup Application-Engine
 	 *  @{
 	 */
@@ -96,5 +95,4 @@ namespace BansheeEngine
 	BS_EXPORT Application& gApplication();
 
 	/** @} */
-	/** @endcond */
 }

BansheeFBXImporter/Include/BsFBXImportData.h

@@ -11,9 +11,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Options that control FBX import
+	/** @addtogroup FBX
+	 *  @{
 	 */
+
+	/**	Options that control FBX import */
 	struct FBXImportOptions
 	{
 		bool importAnimation = true;
@@ -26,9 +28,7 @@ namespace BansheeEngine
 		bool animResample = false;
 	};
 
-	/**
-	 * @brief	Represents a single node in the FBX transform hierarchy.
-	 */
+	/**	Represents a single node in the FBX transform hierarchy. */
 	struct FBXImportNode
 	{
 		~FBXImportNode();
@@ -40,9 +40,7 @@ namespace BansheeEngine
 		Vector<FBXImportNode*> children;
 	};
 
-	/**
-	 * @brief	Contains geometry from one blend shape frame.
-	 */
+	/**	Contains geometry from one blend shape frame. */
 	struct FBXBlendShapeFrame
 	{
 		Vector<Vector3> positions;
@@ -53,28 +51,21 @@ namespace BansheeEngine
 		float weight;
 	};
 
-	/**
-	 * @brief	Contains all geometry for a single blend shape.
-	 */
+	/**	Contains all geometry for a single blend shape. */
 	struct FBXBlendShape
 	{
 		String name;
 		Vector<FBXBlendShapeFrame> frames;
 	};
 
-	/**
-	 * @brief	Contains data about a single bone in a skinned mesh.
-	 */
+	/**	Contains data about a single bone in a skinned mesh. */
 	struct FBXBone
 	{
 		FBXImportNode* node;
 		Matrix4 bindPose;
 	};
 
-	/**
-	 * @brief	Contains a set of bone weights and indices for a single
-	 *			vertex, used in a skinned mesh.
-	 */
+	/** Contains a set of bone weights and indices for a single vertex, used in a skinned mesh. */
 	struct FBXBoneInfluence
 	{
 		FBXBoneInfluence()
@@ -91,9 +82,8 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Represents a single frame in an animation curve. Contains
-	 *			a value at a specific time as well as the in and out tangents
-	 *			at that position.
+	 * Represents a single frame in an animation curve. Contains a value at a specific time as well as the in and out 
+	 * tangents at that position.
 	 */
 	struct FBXKeyFrame
 	{
@@ -103,10 +93,7 @@ namespace BansheeEngine
 		float outTangent;
 	};
 
-	/**
-	 * @brief	Curve with a set of key frames used for animation
-	 *			of a single value.
-	 */
+	/**	Curve with a set of key frames used for animation of a single value. */
 	struct FBXAnimationCurve
 	{
 		Vector<FBXKeyFrame> keyframes;
@@ -114,9 +101,7 @@ namespace BansheeEngine
 		float evaluate(float time);
 	};
 
-	/**
-	 * @brief	Animation curves required to animate a single bone.
-	 */
+	/**	Animation curves required to animate a single bone. */
 	struct FBXBoneAnimation
 	{
 		FBXImportNode* node;
@@ -126,19 +111,14 @@ namespace BansheeEngine
 		FBXAnimationCurve scale[3];
 	};
 
-	/**
-	 * @brief	Animation curve required to animate a blend shape.
-	 */
+	/**	Animation curve required to animate a blend shape. */
 	struct FBXBlendShapeAnimation
 	{
 		String blendShape;
 		FBXAnimationCurve curve;
 	};
 
-	/**
-	 * @brief	Animation clip containing a set of bone or blend shape
-	 *			animations.
-	 */
+	/** Animation clip containing a set of bone or blend shape animations. */
 	struct FBXAnimationClip
 	{
 		String name;
@@ -149,9 +129,7 @@ namespace BansheeEngine
 		Vector<FBXBlendShapeAnimation> blendShapeAnimations;
 	};
 
-	/**
-	 * @brief	Imported mesh data.
-	 */
+	/**	Imported mesh data. */
 	struct FBXImportMesh
 	{
 		FbxMesh* fbxMesh;
@@ -177,9 +155,7 @@ namespace BansheeEngine
 		Vector<FBXImportNode*> referencedBy;
 	};
 
-	/**
-	 * @brief	Scene information used and modified during FBX import.
-	 */
+	/**	Scene information used and modified during FBX import. */
 	struct FBXImportScene
 	{
 		FBXImportScene();
@@ -194,4 +170,5 @@ namespace BansheeEngine
 		Vector<FBXAnimationClip> clips;
 	};
 
+	/** @} */
 }

BansheeFBXImporter/Include/BsFBXImporter.h

@@ -11,6 +11,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup FBX
+	 *  @{
+	 */
+
 	/** Importer implementation that handles FBX/OBJ/DAE/3DS file import by using the FBX SDK. */
 	class BS_FBX_EXPORT FBXImporter : public SpecificImporter
 	{
@@ -123,4 +127,6 @@ namespace BansheeEngine
 		Vector<WString> mExtensions;
 		FbxManager* mFBXManager;
 	};
+
+	/** @} */
 }

BansheeFBXImporter/Include/BsFBXPrerequisites.h

@@ -20,6 +20,14 @@
 #    define BS_FBX_EXPORT
 #endif
 
+/** @addtogroup Plugins/
+
+/** @defgroup FBX FBX
+ *	Mesh importer for FBX file format.
+ */
+
+/** @} */
+
 #define FBXSDK_NEW_API
 #include <fbxsdk.h>
 

BansheeFBXImporter/Include/BsFBXUtility.h

@@ -7,52 +7,47 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Various helper methods to use during FBX import.
+	/** @addtogroup FBX
+	 *  @{
 	 */
+
+	/**	Various helper methods to use during FBX import. */
 	class FBXUtility
 	{
 	public:
-		/**
-		 * @brief	Calculates per-index normals based on the provided smoothing groups.
-		 */
+		/**	Calculates per-index normals based on the provided smoothing groups. */
 		static void normalsFromSmoothing(const Vector<Vector3>& positions, const Vector<int>& indices,
 			const Vector<int>& smoothing, Vector<Vector3>& normals);
 
 		/**
-		 * @brief	Find vertices in the source mesh that have different attributes but have the same
-		 *			indexes, and splits them into two or more vertexes. Mesh with split vertices
-		 *			is output to "dest".
+		 * Find vertices in the source mesh that have different attributes but have the same indexes, and splits them into
+		 * two or more vertexes. Mesh with split vertices is output to @p dest.
 		 *
-		 * @param	source	Source mesh to perform the split on. It's expected the position
-		 *					values are per-vertex, and all other attributes are per-index.
-		 * @param	dest	Output mesh with split vertices. Both vertex positions and
-		 *					attributes are per-vertex.
+		 * @param[in]	source	Source mesh to perform the split on. It's expected the position values are per-vertex, and
+		 *						all other attributes are per-index.
+		 * @param[in]	dest	Output mesh with split vertices. Both vertex positions and attributes are per-vertex.
 		 */
 		static void splitVertices(const FBXImportMesh& source, FBXImportMesh& dest);
 
-		/**
-		 * @brief	Flips the triangle window order for all the triangles in the mesh.
-		 */
+		/**	Flips the triangle window order for all the triangles in the mesh. */
 		static void flipWindingOrder(FBXImportMesh& input);
 
 	private:
-		/**
-		 * @brief	Checks if vertex attributes at the specified indexes are similar enough, or
-		 *			does the vertex require a split.
-		 */
+		/** Checks if vertex attributes at the specified indexes are similar enough, or does the vertex require a split. */
 		static bool needsSplitAttributes(const FBXImportMesh& meshA, int idxA, const FBXImportMesh& meshB, int idxB);
 
 		/**
-		 * @brief	Copies vertex attributes from the source mesh at the specified index, 
-		 *			to the destination mesh at the specified index.
+		 * Copies vertex attributes from the source mesh at the specified index, to the destination mesh at the specified
+		 * index.
 		 */
 		static void copyVertexAttributes(const FBXImportMesh& srcMesh, int srcIdx, FBXImportMesh& destMesh, int dstIdx);
 
 		/**
-		 * @brief	Adds a new vertex to the destination mesh and copies the vertex from the source mesh at the
-		 *			vertex index, and vertex attributes from the source mesh at the source index.
+		 * Adds a new vertex to the destination mesh and copies the vertex from the source mesh at the vertex index, and
+		 * vertex attributes from the source mesh at the source index.
 		 */
 		static void addVertex(const FBXImportMesh& srcMesh, int srcIdx, int srcVertex, FBXImportMesh& destMesh);
 	};
+
+	/** @} */
 }

BansheeFontImporter/Include/BsFontImporter.h

@@ -8,38 +8,33 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Importer implementation that handles font import 
-	 *			by using the FreeType library.
+	/** @addtogroup Font
+	 *  @{
 	 */
+
+	/** Importer implementation that handles font import by using the FreeType library. */
 	class BS_FONT_EXPORT FontImporter : public SpecificImporter
 	{
 	public:
 		FontImporter();
 		virtual ~FontImporter();
 
-		/**
-		 * @copydoc	SpecificImporter::isExtensionSupported
-		 */
+		/** @copydoc SpecificImporter::isExtensionSupported */
 		virtual bool isExtensionSupported(const WString& ext) const override;
 
-		/**
-		 * @copydoc	SpecificImporter::isMagicNumberSupported
-		 */
+		/** @copydoc SpecificImporter::isMagicNumberSupported */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const override;
 
-		/**
-		 * @copydoc	SpecificImporter::import
-		 */
+		/** @copydoc SpecificImporter::import */
 		virtual ResourcePtr import(const Path& filePath, ConstImportOptionsPtr importOptions) override;
 
-		/**
-		 * @copydoc SpecificImporter::createImportOptions
-		 */
+		/** @copydoc SpecificImporter::createImportOptions */
 		virtual ImportOptionsPtr createImportOptions() const override;
 	private:
 		Vector<WString> mExtensions;
 
 		const static int MAXIMUM_TEXTURE_SIZE = 2048;
 	};
+
+	/** @} */
 }

BansheeFontImporter/Include/BsFontPrerequisites.h

@@ -18,4 +18,12 @@
 #    define BS_FONT_EXPORT  __attribute__ ((visibility("default")))
 #else
 #    define BS_FONT_EXPORT
-#endif
+#endif
+
+/** @addtogroup Plugins/
+
+/** @defgroup Font Font
+ *	FreeType importer for font file formats (TTF, OTF).
+ */
+
+/** @} */

BansheeFreeImgImporter/Include/BsFreeImgImporter.h

@@ -8,10 +8,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Importer implementation that handles various import for various
-	 *			image formats using the FreeImg library.
+	/** @addtogroup FreeImg
+	 *  @{
 	 */
+
+	/** Importer implementation that handles various import for various image formats using the FreeImg library. */
 	class FreeImgImporter : public SpecificImporter
 	{
 		struct RawImageData;
@@ -20,37 +21,27 @@ namespace BansheeEngine
 		FreeImgImporter();
 		virtual ~FreeImgImporter();
 
-		/**
-		 * @copydoc	SpecificImporter::isExtensionSupported
-		 */
+		/** @copydoc SpecificImporter::isExtensionSupported */
 		virtual bool isExtensionSupported(const WString& ext) const override;
 
-		/**
-		 * @copydoc	SpecificImporter::isMagicNumberSupported
-		 */
+		/** @copydoc SpecificImporter::isMagicNumberSupported */
 		virtual bool isMagicNumberSupported(const UINT8* magicNumPtr, UINT32 numBytes) const override;
 
-		/**
-		 * @copydoc	SpecificImporter::import
-		 */
+		/** @copydoc SpecificImporter::import */
 		virtual ResourcePtr import(const Path& filePath, ConstImportOptionsPtr importOptions) override;
 
-		/**
-		 * @copydoc SpecificImporter::createImportOptions
-		 */
+		/** @copydoc SpecificImporter::createImportOptions */
 		virtual ImportOptionsPtr createImportOptions() const override;
 	private:
-		/**
-		 * @brief	Converts a magic number into an extension name.
-		 */
+		/**	Converts a magic number into an extension name. */
 		WString magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const;
 
-		/**
-		 * @brief	Imports an image from the provided data stream.
-		 */
+		/**	Imports an image from the provided data stream. */
 		PixelDataPtr importRawImage(DataStreamPtr fileData);
 
 		Vector<WString> mExtensions;
 		UnorderedMap<WString, int> mExtensionToFID;
 	};
+
+	/** @} */
 }

BansheeFreeImgImporter/Include/BsFreeImgPrerequisites.h

@@ -18,4 +18,12 @@
 #    define BS_FREEIMG_EXPORT  __attribute__ ((visibility("default")))
 #else
 #    define BS_FREEIMG_EXPORT
-#endif
+#endif
+
+/** @addtogroup Plugins/
+
+/** @defgroup FreeImg FreeImg
+ *	FreeImg importer for importing most popular image formats (e.g. PSD, PNG, JPG, etc.).
+ */
+
+/** @} */

BansheeMono/Include/BsMonoArray.h

@@ -9,6 +9,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Mono
+	 *  @{
+	 */
+
 	/** Helper class for creating and parsing managed arrays.*/
 	class BS_MONO_EXPORT ScriptArray
 	{
@@ -153,4 +157,6 @@ namespace BansheeEngine
 	private:
 		MonoArray* mInternal;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoAssembly.h

@@ -8,16 +8,15 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains information about a single Mono (i.e. managed) assembly
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Contains information about a single Mono (i.e. managed) assembly. */
 	class BS_MONO_EXPORT MonoAssembly
 	{
 	public:
-		/**
-		 * @brief	Used for uniquely identifying a managed class, normally for use
-		 *			in containers.
-		 */
+		/**	Used for uniquely identifying a managed class, normally for use in containers. */
 		struct ClassId
 		{
 			struct Hash
@@ -41,30 +40,24 @@ namespace BansheeEngine
 	public:
 		virtual ~MonoAssembly();
 
-		/**
-		 * @brief	Returns the name of this assembly.
-		 */
+		/**	Returns the name of this assembly. */
 		const String& getName() const { return mName; }
 
 		/**
-	     * @brief	Attempts to find a managed class with the specified namespace and name
-		 *			in this assembly. Returns null if one cannot be found.
+	     * Attempts to find a managed class with the specified namespace and name in this assembly. Returns null if one
+		 * cannot be found.
 	     */
 		MonoClass* getClass(const String& namespaceName, const String& name) const;
 
-		/**
-		 * @brief	Converts an internal mono representation of a class into engine class.
-		 */
+		/**	Converts an internal mono representation of a class into engine class. */
 		MonoClass* getClass(::MonoClass* rawMonoClass) const;
 
-		/**
-		 * @brief	Returns a list of all classes in the assembly.
-		 */
+		/**	Returns a list of all classes in the assembly. */
 		const Vector<MonoClass*>& getAllClasses() const;
 
 		/**
-	     * @brief	Invokes a zero-parameter static method in the format
-		 *			"Class::Method". Used primarily for invoking an assembly entry point.
+	     * Invokes a zero-parameter static method in the format "Class::Method". Used primarily for invoking an assembly
+		 * entry point.
 	     */
 		void invoke(const String& functionName);
 
@@ -74,34 +67,30 @@ namespace BansheeEngine
 		MonoAssembly(const String& path, const String& name);
 
 		/**
-	     * @brief	Attempts to find a managed class with the specified namespace and name
-		 *			in this assembly. Registers a new class using the provided raw class if
-		 *			one cannot be found. Returns null provided raw class is null.
+	     * Attempts to find a managed class with the specified namespace and name in this assembly. Registers a new class
+		 * using the provided raw class if one cannot be found. Returns null provided raw class is null.
 	     */
 		MonoClass* getClass(const String& namespaceName, const String& name, ::MonoClass* rawMonoClass) const;
 
-		/**
-		 * @brief	Loads an assembly into the specified domain.
-		 */
+		/**	Loads an assembly into the specified domain. */
 		void load(MonoDomain* domain);
 
 		/**
-		 * @brief	Initializes an assembly from an internal mono image.
+		 * Initializes an assembly from an internal mono image.
 		 *
-		 * @note	Normally used for assemblies that were already loaded by the managed runtime
-		 *			as dependencies.
+		 * @note	
+		 * Normally used for assemblies that were already loaded by the managed runtime as dependencies.
 		 */
 		void loadFromImage(MonoImage* image);
 
 		/**
-		 * @brief	Unloads the assembly and all the types associated with it.
-		 *			Caller must ensure not to use any types from this assembly after
-		 *			it has been unloaded.
+		 * Unloads the assembly and all the types associated with it. Caller must ensure not to use any types from this
+		 * assembly after it has been unloaded.
 		 */
 		void unload();
 
 		/**
-	     * @brief	Returns true if the provided name represents a generic class.
+	     * Returns true if the provided name represents a generic class.
 		 *
 		 * @note	This method only analyzes the name to determine if it is in generic class format.
 	     */
@@ -120,4 +109,6 @@ namespace BansheeEngine
 		mutable bool mHaveCachedClassList;
 		mutable Vector<MonoClass*> mCachedClassList;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoClass.h

@@ -7,15 +7,14 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains information about a single Mono (i.e. managed) class.
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Contains information about a single Mono (i.e. managed) class. */
 	class BS_MONO_EXPORT MonoClass
 	{
-		/**
-		 * @brief	Used for uniquely identifying a method in a managed class, normally for use
-		 *			in containers.
-		 */
+		/** Used for uniquely identifying a method in a managed class, normally for use in containers. */
 		struct MethodId
 		{
 			struct Hash
@@ -37,168 +36,153 @@ namespace BansheeEngine
 	public:
 		~MonoClass();
 
-		/**
-		 * @brief	Returns the namespace of this class.
-		 */
+		/**	Returns the namespace of this class. */
 		const String& getNamespace() const { return mNamespace; }
 
-		/**
-		 * @brief	Returns the type name of this class.
-		 */
+		/**	Returns the type name of this class. */
 		const String& getTypeName() const { return mTypeName; }
 
-		/**
-		 * @brief	Returns the full name (Namespace::TypeName) of this class.
-		 */
+		/**	Returns the full name (Namespace::TypeName) of this class. */
 		const String& getFullName() const { return mFullName; }
 
 		/**
-		 * @brief	Returns an object referencing a method with the specified name and number of parameters.
+		 * Returns an object referencing a method with the specified name and number of parameters.
 		 *			
-		 * @note	If the method is overloaded then you should use "getMethodExact". 
-		 *			Does not query base class methods.
-		 *			Returns null if method cannot be found.
+		 * @note	
+		 * If the method is overloaded then you should use getMethodExact(). 
+		 * Does not query base class methods.
+		 * Returns null if method cannot be found.
 		 */
 		MonoMethod* getMethod(const String& name, UINT32 numParams = 0) const;
 
 		/**
-		 * @brief	Returns an object referencing a field with the specified name.
-		 *			Does not query base class fields.
-		 *			Returns null if field cannot be found.
+		 * Returns an object referencing a field with the specified name.
+		 *
+		 * @note
+		 * Does not query base class fields.
+		 * Returns null if field cannot be found.
 		 */
 		MonoField* getField(const String& name) const;
 
 		/**
-		 * @brief	Returns an object referencing a property with the specified name.
-		 *			Does not query base class properties.
-		 *			Throws an exception if the property cannot be found.
+		 * Returns an object referencing a property with the specified name.
+		 *
+		 * @note
+		 * Does not query base class properties.
+		 * Throws an exception if the property cannot be found.
 		 */
 		MonoProperty& getProperty(const String& name);
 
 		/**
-		 * @brief	Returns an instance of an attribute of the specified "monoClass" that is part
-		 *			of this class. Returns null if this class type does not have that type of attribute.
+		 * Returns an instance of an attribute of the specified @p monoClass that is part of this class. Returns null if
+		 * this class type does not have that type of attribute.
 		 */
 		MonoObject* getAttribute(MonoClass* monoClass) const;
 
-		/**
-		 * @brief	Returns the base class of this class. Null if this class has no base.
-		 */
+		/**	Returns the base class of this class. Null if this class has no base. */
 		MonoClass* getBaseClass() const;
 
 		/**
-		 * @brief	Returns an object referencing a method, expects exact method name with parameters.
+		 * Returns an object referencing a method, expects exact method name with parameters.
 		 *			
-		 * @note	Does not query base class methods.
-		 *			Returns null if method cannot be found.
-		 *			Example: name = "CreateInstance", signature = "Vector2,int[]"
+		 * @note	
+		 * Does not query base class methods.
+		 * Returns null if method cannot be found.
+		 * Example: name = "CreateInstance", signature = "Vector2,int[]"
 		 */
 		MonoMethod* getMethodExact(const String& name, const String& signature) const;
 
 		/**
-		 * @brief	Returns all fields belonging to this class.
+		 * Returns all fields belonging to this class.
 		 *
 		 * @note	Be aware this will not include the fields of any base classes.
 		 */
 		const Vector<MonoField*>& getAllFields() const;
 
 		/**
-		 * @brief	Returns all methods belonging to this class.
+		 * Returns all methods belonging to this class.
 		 *
 		 * @note	Be aware this will not include the methods of any base classes.
 		 */
 		const Vector<MonoMethod*>& getAllMethods() const;
 
-		/**
-		 * @brief	Gets all attributes applied to this class.
-		 */
+		/**	Gets all attributes applied to this class. */
 		Vector<MonoClass*> getAllAttributes() const;
 
-		/**
-		 * @brief	Check if this class has an attribute of the type "monoClass".
-		 */
+		/**	Check if this class has an attribute of the type @p monoClass. */
 		bool hasAttribute(MonoClass* monoClass) const;
 
-		/**
-		 * @brief	Check if this class has a field with the specified name. Does not
-		 *			check base classes.
-		 */
+		/**	Check if this class has a field with the specified name. Does not check base classes. */
 		bool hasField(const String& name) const;
 
-		/**
-		 * @brief	Checks if this class is a sub class of the specified class.
-		 */
+		/**	Checks if this class is a sub class of the specified class. */
 		bool isSubClassOf(const MonoClass* monoClass) const;
 
-		/**
-		 * @brief	Checks is the provided object instance of this class' type.
-		 */
+		/**	Checks is the provided object instance of this class' type. */
 		bool isInstanceOfType(MonoObject* object) const;
 
 		/**
-		 * @brief	Shortcut for invoking a method on a class. Invokes a method with the provided name
-		 *			and number of parameters.
+		 * Shortcut for invoking a method on a class. Invokes a method with the provided name and number of parameters.
 		 *
-		 * @param	name		Name of the method to invoke (no parameter list or brackets.
-		 * @param	instance	Object instance on invoke the method on. Null if method is static.
-		 * @param	params		Array containing pointers to method parameters. Array length must be equal to number of parameters. 
-		 *						Can be null if method has no parameters. For value types parameters should be pointers to the values 
-		 *						and for reference types they should be pointers to MonoObject.
-		 * @param	numParams	Number of parameters the method accepts.
+		 * @param[in]	name		Name of the method to invoke (no parameter list or brackets.
+		 * @param[in]	instance	Object instance on invoke the method on. Null if method is static.
+		 * @param[in]	params		Array containing pointers to method parameters. Array length must be equal to number of
+		 *							parameters. Can be null if method has no parameters. For value types parameters should
+		 *							be pointers to the values and for reference types they should be pointers to MonoObject.
+		 * @param[in]	numParams	Number of parameters the method accepts.
 		 *
-		 * @note	You cannot use this to call overloaded methods that have the same number of parameters. Use "getMethodExact" and then
-		 *			invoke the method from the returned method object.
+		 * @note	
+		 * You cannot use this to call overloaded methods that have the same number of parameters. Use getMethodExact() and
+		 * then invoke the method from the returned method object.
 		 */
 		MonoObject* invokeMethod(const String& name, MonoObject* instance = nullptr, void** params = nullptr, UINT32 numParams = 0);
 
 		/**
-		 * @brief	Hooks up an internal call that will trigger the provided method callback when the managed method with the
-		 *			specified name is called. If name is not valid this will silently fail.
+		 * Hooks up an internal call that will trigger the provided method callback when the managed method with the 
+		 * specified name is called. If name is not valid this will silently fail.
 		 */
 		void addInternalCall(const String& name, const void* method);
 
 		/**
-		 * @brief	Returns the internal mono representation of the class.
-		 */
-		::MonoClass* _getInternalClass() const { return mClass; }
-
-		/**
-		 * @brief	Creates a new instance of this class and optionally constructs it.
-		 *			If you don't construct the instance then you should invoke the ".ctor" method manually
-		 *			afterwards.
+		 * Creates a new instance of this class and optionally constructs it. If you don't construct the instance then you
+		 * should invoke the ".ctor" method manually afterwards.
 		 */
 		MonoObject* createInstance(bool construct = true) const;
 
 		/**
-		 * @brief	Creates a new instance of this class and then constructs it using the constructor
-		 *			with the specified number of parameters.
+		 * Creates a new instance of this class and then constructs it using the constructor with the specified number of
+		 * parameters.
 		 *
-		 * @param	params		Array containing pointers to constructor parameters. Array length must be equal to number of parameters. 
-		 * @param	numParams	Number of parameters the constructor accepts.
+		 * @param[in]	params		Array containing pointers to constructor parameters. Array length must be equal to
+		 *							number of parameters. 
+		 * @param[in]	numParams	Number of parameters the constructor accepts.
 		 *
-		 * @note	If the class have multiple constructors with the same number of parameters use the other "createInstance" overload
-		 *			that allows you to provide exact signature.
+		 * @note	If the class have multiple constructors with the same number of parameters use the other 
+		 *			createInstance(const String&, void**) overload that allows you to provide exact signature.
 		 */
 		MonoObject* createInstance(void** params, UINT32 numParams);
 
 		/**
-		 * @brief	Creates a new instance of this class and then constructs it using the constructor
-		 *			with the specified signature.
+		 * Creates a new instance of this class and then constructs it using the constructor with the specified signature.
 		 *
-		 * @param	ctorSignature	Method signature. Example: "Vector2,int[]"
-		 * @param	params			Array containing pointers to constructor parameters. Array length must be equal to number of parameters. 
+		 * @param[in]	ctorSignature	Method signature. Example: "Vector2,int[]"
+		 * @param[in]	params			Array containing pointers to constructor parameters. Array length must be equal to
+		 *								number of parameters. 
 		 */
 		MonoObject* createInstance(const String& ctorSignature, void** params);
+
+		/**	Returns the internal mono representation of the class. */
+		::MonoClass* _getInternalClass() const { return mClass; }
 	private:
 		friend class MonoAssembly;
 
 		/**
-		 * @brief	Constructs a new mono class object.
+		 * Constructs a new mono class object.
 		 * 
-		 * @param	ns				Namespace the class belongs to.
-		 * @param	type			Type name of the class.
-		 * @param	monoClass		Internal mono class.
-		 * @param	parentAssembly	Assembly to which this class belongs.
+		 * @param[in]	ns				Namespace the class belongs to.
+		 * @param[in]	type			Type name of the class.
+		 * @param[in]	monoClass		Internal mono class.
+		 * @param[in]	parentAssembly	Assembly to which this class belongs.
 		 */
 		MonoClass(const String& ns, const String& type, ::MonoClass* monoClass, const MonoAssembly* parentAssembly);
 
@@ -218,4 +202,6 @@ namespace BansheeEngine
 		mutable bool mHasCachedMethods;
 		mutable Vector<MonoMethod*> mCachedMethodList;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoField.h

@@ -8,9 +8,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Returns the level of field visibility in the class.
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Returns the level of field visibility in the class. */
 	enum class MonoFieldVisibility
 	{
 		Private,
@@ -21,67 +23,55 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Encapsulates information about a single Mono (i.e. managed) field
-	 *			belonging to some managed class. This object also allows you to set
-	 *			or retrieve values to/from specific instances containing the field.
+	 * Encapsulates information about a single Mono (i.e. managed) field belonging to some managed class. This object also
+	 * allows you to set or retrieve values to/from specific instances containing the field.
 	 */
 	class BS_MONO_EXPORT MonoField
 	{
 	public:
-		/**
-		 * @brief	Returns the name of the field.
-		 */
+		/**	Returns the name of the field. */
 		const String& getName() const { return mName; }
 
-		/**
-		 * @brief	Returns the class representing the type of data the field holds.
-		 */
+		/**	Returns the class representing the type of data the field holds. */
 		MonoClass* getType();
 
 		/**
-		 * @brief	Retrieves value currently set in the field on the specified object instance.
-		 *			If field is static object instance can be null. 
+		 * Retrieves value currently set in the field on the specified object instance. If field is static object instance
+		 * can be null. 
 		 *
-		 * @note	Value will be a pointer to raw data type for value types (e.g. int, float), and a MonoObject*
-		 *			for reference types.
+		 * @note	
+		 * Value will be a pointer to raw data type for value types (e.g. int, float), and a MonoObject* for reference types.
 		 */
 		void getValue(MonoObject* instance, void* outValue);
 
 		/**
-		 * @brief	Retrieves value currently set in the field on the specified object instance.
-		 *			If field is static object instance can be null. If returned value is a value
-		 *			type it will be boxed.
+		 * Retrieves value currently set in the field on the specified object instance. If field is static object instance
+		 * can be null. If returned value is a value type it will be boxed.
 		 */
 		MonoObject* getValueBoxed(MonoObject* instance);
 
 		/**
-		 * @brief	Sets a value for the field on the specified object instance.
-		 *			If field is static object instance can be null. 
+		 * Sets a value for the field on the specified object instance. If field is static object instance can be null. 
 		 *
-		 * @note	Value should be a pointer to raw data type for value types (e.g. int, float), and a MonoObject*
-		 *			for reference types.
+		 * @note	
+		 * Value should be a pointer to raw data type for value types (e.g. int, float), and a MonoObject* for reference 
+		 * types.
 		 */
 		void setValue(MonoObject* instance, void* value);
 
-		/**
-		 * @brief	Checks if field has an attribute of the specified type.
-		 */
+		/**	Checks if field has an attribute of the specified type. */
 		bool hasAttribute(MonoClass* monoClass);
 
 		/**
-		 * @brief	Returns an instance of an attribute of the specified type. Returns null
-		 *			if the field doesn't have such an attribute.
+		 * Returns an instance of an attribute of the specified type. Returns null if the field doesn't have such an 
+		 * attribute.
 		 */
 		MonoObject* getAttribute(MonoClass* monoClass);
 
-		/**
-		 * @brief	Returns field visibility in the class.
-		 */
+		/**	Returns field visibility in the class. */
 		MonoFieldVisibility getVisibility();
 
-		/**
-		 * @brief	Query if the field is static.
-		 */
+		/**	Query if the field is static. */
 		bool isStatic();
 
 	private:
@@ -93,4 +83,6 @@ namespace BansheeEngine
 		MonoClassField* mField;
 		MonoClass* mFieldType;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoManager.h

@@ -9,18 +9,18 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Available Mono versions
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Available Mono versions. */
 	enum class MonoVersion
 	{
 		v4_0,
 		v4_5
 	};
 
-	/**
-	 * @brief	Loads Mono script assemblies and manages script objects.
-	 */
+	/**	Loads Mono script assemblies and manages script objects. */
 	class BS_MONO_EXPORT MonoManager : public Module<MonoManager>
 	{
 	public:
@@ -28,83 +28,66 @@ namespace BansheeEngine
 		~MonoManager();
 
 		/**
-		 * @brief	Loads a new assembly from the provided path.
+		 * Loads a new assembly from the provided path.
 		 *
-		 * @param	path	Absolute path to the assembly .dll.
-		 * @param	name	Unique name for the assembly.
+		 * @param[in]	path	Absolute path to the assembly .dll.
+		 * @param[in]	name	Unique name for the assembly.
 		 */
 		MonoAssembly& loadAssembly(const String& path, const String& name);
 
-		/**
-		 * @brief	Searches all loaded assemblies for the specified class.
-		 */
+		/**	Searches all loaded assemblies for the specified class. */
 		MonoClass* findClass(const String& ns, const String& typeName);
 
-		/**
-		 * @brief	Searches all loaded assemblies for the specified class.
-		 */
+		/**	Searches all loaded assemblies for the specified class. */
 		MonoClass* findClass(::MonoClass* rawMonoClass);
 
-		/**
-		 * @brief	Returns the current Mono domains.
-		 */
+		/**	Returns the current Mono domains. */
 		MonoDomain* getDomain() const { return mScriptDomain; }
 
 		/**
-		 * @brief	Attempts to find a previously loaded assembly with the specified name.
-		 *			Returns null if assembly cannot be found.
+		 * Attempts to find a previously loaded assembly with the specified name. Returns null if assembly cannot be found.
 		 */
 		MonoAssembly* getAssembly(const String& name) const;
 
 		/**
-		 * @brief	Unloads the active domain all script assemblies are loaded in
-		 *			and destroys any managed objects associated with it.
+		 * Unloads the active domain all script assemblies are loaded in and destroys any managed objects associated with it.
 		 */
 		void unloadScriptDomain();
 
 		/**
-		 * @brief	Loads a new script domain. If another domain already exists it will be unloaded. This will also
-		 *			restore any previously loaded assemblies.
+		 * Loads a new script domain. If another domain already exists it will be unloaded. This will also restore any
+		 * previously loaded assemblies.
 		 */
 		void loadScriptDomain();
 
 		/**
-		 * @brief	Returns the path of the folder where Mono framework assemblies are located. Path is relative
-		 * 			to the application executable.
+		 * Returns the path of the folder where Mono framework assemblies are located. Path is relative to the application
+		 * executable.
 		 */
 		Path getFrameworkAssembliesFolder() const;
 
 		/**
-		 * @brief	Returns the path to the Mono /etc folder that is required for initializing Mono. Path is relative
-		 * 			to the application executable.
+		 * Returns the path to the Mono /etc folder that is required for initializing Mono. Path is relative to the
+		 * application executable.
 		 */
 		Path getMonoEtcFolder() const;
 
-		/**
-		 * @brief	Returns the absolute path to the Mono compiler.
-		 */
+		/**	Returns the absolute path to the Mono compiler. */
 		Path getCompilerPath() const;
 
 		/**
-		 * @brief	Registers a new script type. This should be done before any assembly loading is done.
-		 *			Upon assembly load these script types will be initialized with necessary information about their
-		 *			managed counterparts.
+		 * Registers a new script type. This should be done before any assembly loading is done. Upon assembly load these
+		 * script types will be initialized with necessary information about their managed counterparts.
 		 */
 		static void registerScriptType(ScriptMeta* metaData);
 
-		/**  
-		 * @brief	Triggered when the assembly domain and all relevant assemblies are about to be unloaded.
-		 */
+		/** Triggered when the assembly domain and all relevant assemblies are about to be unloaded. */
 		Event<void()> onDomainUnload;
 	private:
-		/**
-		 * @brief	Initializes a previous loaded assembly.
-		 */
+		/**	Initializes a previous loaded assembly. */
 		void initializeAssembly(MonoAssembly& assembly);
 
-		/**
-		 * @brief	Returns a list of all types that will be initializes with their assembly gets loaded.
-		 */
+		/**	Returns a list of all types that will be initializes with their assembly gets loaded. */
 		static UnorderedMap<String, Vector<ScriptMeta*>>& getScriptMetaData()
 		{
 			static UnorderedMap<String, Vector<ScriptMeta*>> mTypesToInitialize;
@@ -116,4 +99,6 @@ namespace BansheeEngine
 		MonoDomain* mRootDomain;
 		bool mIsCoreLoaded;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoMethod.h

@@ -7,11 +7,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Mono
+	 *  @{
+	 */
 
 	/**
-	 * @brief	Encapsulates information about a single Mono (i.e. managed) method
-	 *			belonging to some managed class. This object also allows you to invoke
-	 *			the method.
+	 * Encapsulates information about a single Mono (i.e. managed) method belonging to some managed class. This object also
+	 * allows you to invoke the method.
 	 */
 	class BS_MONO_EXPORT MonoMethod
 	{
@@ -19,75 +21,57 @@ namespace BansheeEngine
 		~MonoMethod();
 
 		/**
-		 * @brief	Invokes the method on the provided object instance. 
-		 *			This does not respect polymorphism and will invoke the exact method
-		 *			of the class this object was retrieved from. Use "invokeVirtual" if you
-		 *			need polymorphism.
-		 *
-		 * @param	instance	Instance of the object to invoke the method on. Can be null for static methods.
-		 * @param	param		Array of parameters to pass to the method. Caller must ensure they match method 
-		 *						parameter count and type. For value types parameters should be pointers to the 
-		 *						values and for reference types they should be pointers to MonoObject.
+		 * Invokes the method on the provided object instance. This does not respect polymorphism and will invoke the exact
+		 * method of the class this object was retrieved from. Use invokeVirtual() if you need polymorphism.
 		 *
-		 @returns	A boxed return value, or null if method has no return value.
+		 * @param[in]	instance	Instance of the object to invoke the method on. Can be null for static methods.
+		 * @param[in]	param		Array of parameters to pass to the method. Caller must ensure they match method 
+		 *							parameter count and type. For value types parameters should be pointers to the 
+		 *							values and for reference types they should be pointers to MonoObject.
+		 * @return					A boxed return value, or null if method has no return value.
 		 */
 		MonoObject* invoke(MonoObject* instance, void** params);
 
 		/**
-		 * @brief	Invokes the method on the provided object instance. If the instance has an override of this
-		 *			method it will be called.
+		 * Invokes the method on the provided object instance. If the instance has an override of this method it will be
+		 * called.
 		 *
-		 * @param	instance	Instance of the object to invoke the method on.
-		 * @param	param		Array of parameters to pass to the method. Caller must ensure they match method 
-		 *						parameter count and type. For value types parameters should be pointers to the 
-		 *						values and for reference types they should be pointers to MonoObject.
-		 *
-		 * @returns	A boxed return value, or null if method has no return value.
+		 * @param[in]	instance	Instance of the object to invoke the method on.
+		 * @param[in]	param		Array of parameters to pass to the method. Caller must ensure they match method 
+		 *							parameter count and type. For value types parameters should be pointers to the 
+		 *							values and for reference types they should be pointers to MonoObject.
+		 * @return					A boxed return value, or null if method has no return value.
 		 */
 		MonoObject* invokeVirtual(MonoObject* instance, void** params);
 
 		/**
-		 * @brief	Gets a thunk for this method. A thunk is a C++ like function
-		 * 			pointer that you can use for calling the method.
+		 * Gets a thunk for this method. A thunk is a C++ like function pointer that you can use for calling the method.
 		 *
 		 * @note	This is the fastest way of calling managed code.
 		 */
 		void* getThunk() const;
 
-		/**
-		 * @brief	Returns the name of the method.
-		 */
+		/**	Returns the name of the method. */
 		String getName() const;
 
-		/**
-		 * @brief	Returns the type of the return value. Returns null if method
-		 *			has no return value.
-		 */
+		/** Returns the type of the return value. Returns null if method has no return value. */
 		MonoClass* getReturnType() const;
 
-		/**
-		 * @brief	Returns the number of parameters the method expects.
-		 */
+		/**	Returns the number of parameters the method expects. */
 		UINT32 getNumParameters() const;
 
-		/**
-		 * @brief	Returns the type of the method parameter at the specified index.
-		 */
+		/**	Returns the type of the method parameter at the specified index. */
 		MonoClass* getParameterType(UINT32 paramIdx) const;
 
-		/**
-		 * @brief	Returns true if the method doesn't require a class instance.
-		 */
+		/**	Returns true if the method doesn't require a class instance. */
 		bool isStatic() const;
 
-		/**
-		 * @brief	Checks if method has an attribute of the specified type.
-		 */
+		/**	Checks if method has an attribute of the specified type. */
 		 bool hasAttribute(MonoClass* monoClass) const;
 
 		/**
-		 * @brief	Returns an instance of an attribute of the specified type. Returns null
-		 *			if the method doesn't have such an attribute.
+		 * Returns an instance of an attribute of the specified type. Returns null if the method doesn't have such an
+		 * attribute.
 		 */
 		MonoObject* getAttribute(MonoClass* monoClass) const;
 
@@ -107,4 +91,6 @@ namespace BansheeEngine
 		mutable bool mIsStatic;
 		mutable bool mHasCachedSignature;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoPrerequisites.h

@@ -20,6 +20,14 @@
 #    define BS_MONO_EXPORT
 #endif
 
+/** @addtogroup Plugins/
+
+/** @defgroup Mono Mono
+ *	Scripting language backend using Mono's CLR.
+ */
+
+/** @} */
+
 namespace BansheeEngine
 {
 	class MonoManager;

BansheeMono/Include/BsMonoProperty.h

@@ -7,57 +7,54 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Mono
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Encapsulates information about a single Mono (i.e. managed) property
-	 *			belonging to some managed class. This object also allows you to set
-	 *			or retrieve values to/from specific instances containing the property.
+	 * Encapsulates information about a single Mono (i.e. managed) property belonging to some managed class. This object
+	 * also allows you to set or retrieve values to/from specific instances containing the property.
 	 */
 	class BS_MONO_EXPORT MonoProperty
 	{
 	public:
 		/**
-		 * @brief	Returns a boxed value contained in the property in the specified instance.
+		 * Returns a boxed value contained in the property in the specified instance.
 		 *
-		 * @param	instance	Object instance to access the property on. Can be null for static properties.
-		 *
-		 * @returns	A boxed value of the property.
+		 * @param[in]	instance	Object instance to access the property on. Can be null for static properties.
+		 * @return					A boxed value of the property.
 		 */
 		MonoObject* get(MonoObject* instance) const;
 
 		/**
-		 * @brief	Sets a value of the property in the specified instance. 
+		 * Sets a value of the property in the specified instance. 
 		 *
-		 * @param	instance	Object instance to access the property on. Can be null for static properties.
-		 * @param	value		Value to set on the property. For value type it should be a pointer to the 
-		 *						value and for reference type it should be a pointer to MonoObject.
+		 * @param[in]	instance	Object instance to access the property on. Can be null for static properties.
+		 * @param[in]	value		Value to set on the property. For value type it should be a pointer to the value and for
+		 *							reference type it should be a pointer to MonoObject.
 		 */
 		void set(MonoObject* instance, void* value) const;
 
 		/**
-		 * @brief	Returns a boxed value contained in the property in the specified instance. Used for properties
-		 *			with indexers.
-		 *
-		 * @param	instance	Object instance to access the property on. Can be null for static properties.
-		 * @param	index		Index of the value to retrieve.
+		 * Returns a boxed value contained in the property in the specified instance. Used for properties with indexers.
 		 *
-		 * @returns	A boxed value of the property.
+		 * @param[in]	instance	Object instance to access the property on. Can be null for static properties.
+		 * @param[in]	index		Index of the value to retrieve.
+		 * @return					A boxed value of the property.
 		 */
 		MonoObject* getIndexed(MonoObject* instance, UINT32 index) const;
 
 		/**
-		 * @brief	Sets a value of the property in the specified instance. Used for properties
-		 *			with indexers.
+		 * Sets a value of the property in the specified instance. Used for properties with indexers.
 		 *
-		 * @param	instance	Object instance to access the property on. Can be null for static properties.
-		 * @param	index		Index of the value to set.
-		 * @param	value		Value to set on the property. For value type it should be a pointer to the 
-		 *						value and for reference type it should be a pointer to MonoObject.
+		 * @param[in]	instance	Object instance to access the property on. Can be null for static properties.
+		 * @param[in]	index		Index of the value to set.
+		 * @param[in]	value		Value to set on the property. For value type it should be a pointer to the value and for
+		 *							reference type it should be a pointer to MonoObject.
 		 */
 		void setIndexed(MonoObject* instance, UINT32 index, void* value) const;
 
-		/**
-		 * @brief	Returns the data type the property holds.
-		 */
+		/**	Returns the data type the property holds. */
 		MonoClass* getReturnType();
 	private:
 		friend class MonoClass;
@@ -69,4 +66,6 @@ namespace BansheeEngine
 		::MonoMethod* mSetMethod;
 		MonoClass* mGetReturnType;
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsMonoUtil.h

@@ -11,16 +11,15 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Utility class containing methods for various common Mono/Script related
-	 *			operations.
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Utility class containing methods for various common Mono/Script related operations. */
 	class BS_MONO_EXPORT MonoUtil
 	{
 	public:
-		/**
-		 * @brief	Converts a Mono (i.e. managed) string to a native wide string.
-		 */
+		/**	Converts a Mono (i.e. managed) string to a native wide string. */
 		static WString monoToWString(MonoString* str)
 		{
 			if(str == nullptr)
@@ -36,9 +35,7 @@ namespace BansheeEngine
 			return ret;
 		}
 
-		/**
-		 * @brief	Converts a Mono (i.e. managed) string to a native narrow string.
-		 */
+		/**	Converts a Mono (i.e. managed) string to a native narrow string. */
 		static String monoToString(MonoString* str)
 		{
 			if(str == nullptr)
@@ -54,9 +51,7 @@ namespace BansheeEngine
 			return ret;
 		}
 
-		/**
-		 * @brief	Converts a native wide string to a Mono (i.e. managed) string.
-		 */
+		/**	Converts a native wide string to a Mono (i.e. managed) string. */
 		static MonoString* wstringToMono(const WString& str)
 		{
 			if (sizeof(wchar_t) == 2) // Assuming UTF-16
@@ -75,17 +70,13 @@ namespace BansheeEngine
 			}
 		}
 
-		/**
-		 * @brief	Converts a native narrow string to a Mono (i.e. managed) string.
-		 */
+		/**	Converts a native narrow string to a Mono (i.e. managed) string. */
 		static MonoString* stringToMono(const String& str)
 		{
 			return wstringToMono(toWString(str));
 		}
 
-		/**
-		 * @brief	Outputs name and namespace for the type of the specified object.
-		 */
+		/**	Outputs name and namespace for the type of the specified object. */
 		static void getClassName(MonoObject* obj, String& ns, String& typeName)
 		{
 			if (obj == nullptr)
@@ -95,9 +86,7 @@ namespace BansheeEngine
 			getClassName(monoClass, ns, typeName);
 		}
 
-		/**
-		 * @brief	Outputs name and namespace for the specified type.
-		 */
+		/**	Outputs name and namespace for the specified type. */
 		static void getClassName(::MonoClass* monoClass, String& ns, String& typeName)
 		{
 			::MonoClass* nestingClass = mono_class_get_nesting_type(monoClass);
@@ -132,17 +121,13 @@ namespace BansheeEngine
 			}
 		}
 
-		/**
-		 * @copydoc	throwIfException
-		 */
+		/** @copydoc throwIfException */
 		static void throwIfException(MonoException* exception)
 		{
 			throwIfException(reinterpret_cast<MonoObject*>(exception));
 		}
 
-		/**
-		 * @brief	Throws a native exception if the provided object is a valid managed exception.
-		 */
+		/**	Throws a native exception if the provided object is a valid managed exception. */
 		static void throwIfException(MonoObject* exception)
 		{
 			if(exception != nullptr)
@@ -172,4 +157,6 @@ namespace BansheeEngine
 			throwIfException(exception);
 		}
 	};
+
+	/** @} */
 }

BansheeMono/Include/BsScriptMeta.h

@@ -6,9 +6,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains information required for initializing and handling a single script class.
+	/** @addtogroup Mono
+	 *  @{
 	 */
+
+	/**	Contains information required for initializing and handling a single script class. */
 	struct BS_MONO_EXPORT ScriptMeta
 	{
 		ScriptMeta();
@@ -17,8 +19,19 @@ namespace BansheeEngine
 		String ns; /**< Namespace the script class is located in. */
 		String name; /**< Type name of the script class. */
 		String assembly; /**< Name of the assembly the script class is located in. */
-		std::function<void()> initCallback; /**< Callback that will be triggered when assembly containing the class is loaded or refreshed. Used for one time initialization. */
-		MonoClass* scriptClass; /**< Class object describing the script class. Only valid after assembly containing this type was loaded. */			
-		MonoField* thisPtrField; /**< Field object that contains a pointer to the native instance of the script object. Only valid after assembly containing this type was loaded. */
+		/**
+		 * Callback that will be triggered when assembly containing the class is loaded or refreshed. Used for one time 
+		 * initialization.
+		 */
+		std::function<void()> initCallback;
+		/** Class object describing the script class. Only valid after assembly containing this type was loaded.  */
+		MonoClass* scriptClass;	
+		/**
+		 * Field object that contains a pointer to the native instance of the script object. Only valid after assembly
+		 * containing this type was loaded.
+		 */
+		MonoField* thisPtrField;
 	};
+
+	/** @} */
 }

BansheeOISInput/Include/BsInputHandlerOIS.h

@@ -13,29 +13,25 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup OISInput
+	 *  @{
+	 */
+
 	class InputHandlerOIS;
 
-	/**
-	 * @brief	Listens for events from a specific OIS joystick device.
-	 */
+	/**	Listens for events from a specific OIS joystick device. */
 	class BS_OIS_EXPORT GamepadEventListener : public OIS::JoyStickListener
 	{
 	public:
 		GamepadEventListener(InputHandlerOIS* parentHandler, UINT32 joystickIdx);
 
-		/**
-		 * @brief	Called by OIS whenever a gamepad/joystick button is pressed.
-		 */
+		/**	Called by OIS whenever a gamepad/joystick button is pressed. */
 		virtual bool buttonPressed(const OIS::JoyStickEvent& arg, int button) override;
 
-		/**
-		 * @brief	Called by OIS whenever a gamepad/joystick button is released.
-		 */
+		/**	Called by OIS whenever a gamepad/joystick button is released. */
 		virtual bool buttonReleased(const OIS::JoyStickEvent& arg, int button) override;
 
-		/**
-		 * @brief	Called by OIS whenever a gamepad/joystick axis is moved.
-		 */
+		/**	Called by OIS whenever a gamepad/joystick axis is moved. */
 		virtual bool axisMoved(const OIS::JoyStickEvent& arg, int axis) override;
 
 	private:
@@ -43,15 +39,11 @@ namespace BansheeEngine
 		InputHandlerOIS* mParentHandler;
 	};
 
-	/**
-	 * @brief	Raw input handler using OIS library for acquiring input.
-	 */
+	/**	Raw input handler using OIS library for acquiring input. */
 	class BS_OIS_EXPORT InputHandlerOIS : public RawInputHandler, public OIS::KeyListener, 
 		public OIS::MouseListener
 	{
-		/**
-		 * @brief	Holding data about an active gamepad object.
-		 */
+		/**	Holding data about an active gamepad object. */
 		struct GamepadData
 		{
 			OIS::JoyStick* gamepad;
@@ -63,71 +55,50 @@ namespace BansheeEngine
 		virtual ~InputHandlerOIS();
 
 	private:
-		/**
-		 * @brief	Called by OIS whenever a keyboard button is pressed.
-		 */
+		/**	Called by OIS whenever a keyboard button is pressed. */
 		virtual bool keyPressed(const OIS::KeyEvent& arg) override;
 
-		/**
-		 * @brief	Called by OIS whenever a keyboard button is released.
-		 */
+		/**	Called by OIS whenever a keyboard button is released. */
 		virtual bool keyReleased(const OIS::KeyEvent& arg) override;
 
-		/**
-		 * @brief	Called by OIS whenever mouse is moved.
-		 */
+		/**	Called by OIS whenever mouse is moved. */
 		virtual bool mouseMoved(const OIS::MouseEvent& arg) override;
 
-		/**
-		 * @brief	Called by OIS whenever is a mouse button pressed.
-		 */
+		/**	Called by OIS whenever is a mouse button pressed. */
 		virtual bool mousePressed(const OIS::MouseEvent& arg, OIS::MouseButtonID id) override;
 
-		/**
-		 * @brief	Called by OIS whenever is a mouse button released
-		 */
+		/**	Called by OIS whenever is a mouse button released. */
 		virtual bool mouseReleased(const OIS::MouseEvent& arg, OIS::MouseButtonID id) override;
 
-		/**
-		 * @brief	Called once per frame.
-		 *
-		 * @note	Internal method.
-		 */
-		virtual void _update() override;
-
-		/**
-		 * @brief	Called whenever the currently focused window changes.
-		 *
-		 * @note	Internal method.
-		 */
-		virtual void _inputWindowChanged(const RenderWindow& win) override;
-
-		/**
-		 * @brief	Converts an OIS key code into engine button code.
-		 */
+		/**	Converts an OIS key code into engine button code. */
 		static ButtonCode keyCodeToButtonCode(OIS::KeyCode keyCode);
 
-		/**
-		 * @brief	Converts an OIS mouse button code into engine button code.
-		 */
+		/**	Converts an OIS mouse button code into engine button code. */
 		static ButtonCode mouseButtonToButtonCode(OIS::MouseButtonID mouseBtn);
 
-		/**
-		 * @brief	Converts an OIS gamepad button code into engine button code.
-		 */
+		/**	Converts an OIS gamepad button code into engine button code. */
 		static ButtonCode gamepadButtonToButtonCode(INT32 joystickCode);
 
+		/** @cond INTERNAL */
+
+		/** Called once per frame. */
+		virtual void _update() override;
+
+		/** Called whenever the currently focused window changes. */
+		virtual void _inputWindowChanged(const RenderWindow& win) override;
+
+		/** @endcond */
+
 	private:
 		friend class GamepadEventListener;
 
 		/**
-		 * @brief	Smooths the input mouse axis value. Smoothing makes the changes to
-		 *			the axis more gradual depending on previous values.
+		 * Smooths the input mouse axis value. Smoothing makes the changes to the axis more gradual depending on previous
+		 * values.
 		 *
-		 * @param	value	Value to smooth.
-		 * @param	idx		Index of the mouse axis to smooth, 0 - horizontal, 1 - vertical.
-		 *
-		 * @returns	Smoothed value.
+		 * @param[in]	value	Value to smooth.
+		 * @param[in]	idx		Index of the mouse axis to smooth, 0 - horizontal, 1 - vertical.
+		 * @return				Smoothed value.
 		 */
 		float smoothMouse(float value, UINT32 idx);
 
@@ -145,4 +116,6 @@ namespace BansheeEngine
 
 		UINT64 mTimestampClockOffset;
 	};
+
+	/** @} */
 }

BansheeOISInput/Include/BsOISPrerequisites.h

@@ -18,4 +18,12 @@
 #    define BS_OIS_EXPORT  __attribute__ ((visibility("default")))
 #else
 #    define BS_OIS_EXPORT
-#endif
+#endif
+
+/** @addtogroup Plugins/
+
+/** @defgroup OISInput OISInput
+ *	OIS implementation for raw keyboard/mouse/gamepad input.
+ */
+
+/** @} */

BansheeSL/Include/BsSLFXCompiler.h

@@ -15,6 +15,10 @@ extern "C" {
 
 namespace BansheeEngine
 {
+	/** @addtogroup BansheeSL
+	 *  @{
+	 */
+
 	/**	Contains the results of compilation returned from the BSLFXCompiler. */
 	struct BSLFXCompileResult
 	{
@@ -245,4 +249,6 @@ namespace BansheeEngine
 		/** Returns one of the builtin textures based on their name. */
 		static HTexture getBuiltinTexture(const String& name);
 	};
+
+	/** @} */
 }

BansheeSL/Include/BsSLImporter.h

@@ -7,10 +7,14 @@
 
 namespace BansheeEngine
 {
-	/**
-	* @brief	Importer using for importing a shader written using the BSL syntax.
-	* 			Shader files are plain text files ending with ".bsl" extension.
-	*/
+	/** @addtogroup BansheeSL
+	 *  @{
+	 */
+
+	/** 
+	 * Importer using for importing a shader written using the BSL syntax. Shader files are plain text files ending with
+	 * ".bsl" extension.
+	 */
 	class BS_SL_EXPORT SLImporter : public SpecificImporter
 	{
 	public:
@@ -26,4 +30,6 @@ namespace BansheeEngine
 		/** @copydoc SpecificImporter::import */
 		virtual ResourcePtr import(const Path& filePath, ConstImportOptionsPtr importOptions) override;
 	};
+
+	/** @} */
 }

BansheeSL/Include/BsSLPrerequisites.h

@@ -20,6 +20,14 @@
 #    define BS_SL_EXPORTS
 #endif
 
+/** @addtogroup Plugins/
+
+/** @defgroup BansheeSL BansheeSL
+ *	Implementation of the Banshee Shading Language.
+ */
+
+/** @} */
+
 namespace BansheeEngine
 {
 	const String SystemName = "BansheeSL";

RenderBeast/Include/BsLightRendering.h

@@ -8,6 +8,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	BS_PARAM_BLOCK_BEGIN(PerLightParamBuffer)
 		BS_PARAM_BLOCK_ENTRY(Vector4, gLightPositionAndType)
 		BS_PARAM_BLOCK_ENTRY(Vector4, gLightColorAndIntensity)
@@ -95,4 +99,6 @@ namespace BansheeEngine
 		MaterialParamTextureCore mGBufferB;
 		MaterialParamTextureCore mGBufferDepth;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsRenderBeast.h

@@ -12,6 +12,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	class BeastRenderableElement;
 
 	/** Semantics that may be used for signaling the renderer for what is a certain shader parameter used for. */
@@ -260,4 +264,6 @@ namespace BansheeEngine
 		SPtr<RenderBeastOptions> mOptions;
 		bool mOptionsDirty;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsRenderBeastFactory.h

@@ -7,23 +7,25 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	const String SystemName = "RenderBeast";
 
 	/**
-	 * @brief	Renderer factory implementation that creates and initializes the default Banshee renderer.
-	 *			Used by the RendererManager.
+	 * Renderer factory implementation that creates and initializes the default Banshee renderer. Used by the 
+	 * RendererManager.
 	 */
 	class BS_BSRND_EXPORT RenderBeastFactory : public RendererFactory
 	{
 	public:
-		/**
-		 * @copydoc	RendererFactory::create
-		 */
+		/** @copydoc RendererFactory::create */
 		virtual CoreRendererPtr create() override;
 
-		/**
-		 * @copydoc	RendererFactory::name
-		 */
+		/** @copydoc RendererFactory::name */
 		virtual const String& name() const override;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsRenderBeastOptions.h

@@ -8,9 +8,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Texture filtering options for RenderBeast.
+	/** @addtogroup RenderBeast
+	 *  @{
 	 */
+
+	/** Texture filtering options for RenderBeast. */
 	enum class RenderBeastFiltering
 	{
 		Bilinear, /**< Sample linearly in X and Y directions within a texture mip level. */
@@ -18,50 +20,43 @@ namespace BansheeEngine
 		Anisotropic /**< High quality dynamic filtering that improves quality of angled surfaces */
 	};
 
-	/**
-	 * @brief	A set of options used for controlling the 
-	 *			rendering of the RenderBeast renderer.
-	 */
+	/** A set of options used for controlling the rendering of the RenderBeast renderer. */
 	struct BS_BSRND_EXPORT RenderBeastOptions : public CoreRendererOptions
 	{
-		/**
-		 * @brief	Type of filtering to use for all textures on scene elements.
-		 */
+		/**	Type of filtering to use for all textures on scene elements. */
 		RenderBeastFiltering filtering = RenderBeastFiltering::Anisotropic;
 
 		/**
-		 * @brief	Maximum number of samples to be used when performing anisotropic
-		 *			filtering. Only relevant if ::filter is set to RenderBeastFiltering::Anisotropic.
+		 * Maximum number of samples to be used when performing anisotropic filtering. Only relevant if #filtering is set to
+		 * RenderBeastFiltering::Anisotropic.
 		 */
 		UINT32 anisotropyMax = 16;
 
 		/**
-		 * @brief	Number of samples per pixel. More samples means less aliasing but this may
-		 *			seriously increase fillrate and memory consumption on the GPU.
+		 * Number of samples per pixel. More samples means less aliasing but this may seriously increase fillrate and memory
+		 * consumption on the GPU.
 		 */
-
 		UINT32 msaa = 1;
 
 		/** 
-		 * All colors output from shaders will be automatically converted to gamma 
-		 * space when written to render target(s). Normally used when the renderer
-		 * performs calculations in linear space.
+		 * All colors output from shaders will be automatically converted to gamma space when written to render target(s). 
+		 * Normally used when the renderer performs calculations in linear space.
 		 */
 		bool gammaCorrect = true; 
 
 		/**
-		 * High dynamic range allows light intensity to be more correctly recorded
-		 * when rendering by allowing for a larger range of values. The stored light
-		 * is then converted into visible colors using a tone mapping operator depending
+		 * High dynamic range allows light intensity to be more correctly recorded when rendering by allowing for a larger
+		 * range of values. The stored light is then converted into visible colors using a tone mapping operator depending
 		 * on average scene brightness.
 		 */
 		bool hdr = false;
 
 		/**
-		 * Controls if and how a render queue groups renderable objects by material in 
-		 * order to reduce number of state changes. Sorting by material can reduce CPU usage
-		 * but could increase overdraw.
+		 * Controls if and how a render queue groups renderable objects by material in order to reduce number of state
+		 * changes. Sorting by material can reduce CPU usage but could increase overdraw.
 		 */
 		StateReduction stateReductionMode = StateReduction::Distance;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsRenderBeastPrerequisites.h

@@ -20,6 +20,14 @@
 #    define BS_BSRND_EXPORT
 #endif
 
+/** @addtogroup Plugins/
+
+/** @defgroup RenderBeast RenderBeast
+ *	Banshee's default renderer implementation.
+ */
+
+/** @} */
+
 namespace BansheeEngine
 {
 	class StaticRenderableHandler;

RenderBeast/Include/BsRenderTargets.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Allocates and handles all the required render targets
-	 *			for rendering a scene from a specific viewport.
+	 * Allocates and handles all the required render targets for rendering a scene from a specific viewport.
 	 *
 	 * @note	Core thread only.
 	 */
@@ -17,82 +20,61 @@ namespace BansheeEngine
 	{
 	public:
 		/**
-		 * @brief	Creates a new set of render targets. This will not actually allocate 
-		 *			the internal render targets - this happens the first time you call ::bind.
+		 * Creates a new set of render targets. This will not actually allocate the internal render targets - this happens
+		 * the first time you call bind().
 		 *
-		 * @param	viewport		Viewport that the render targets will be used for. Determines size of the
-		 *							render targets, and the output color render target.
-		 * @param	hdr				Should the render targets support high dynamic range rendering.
-		 * @param	numSamples		Number of samples to use if multisampling is active. Provide 0 or 1 if
-		 *							multisampled targets are not needed.
+		 * @param[in]	viewport		Viewport that the render targets will be used for. Determines size of the render
+		 *								targets, and the output color render target.
+		 * @param[in]	hdr				Should the render targets support high dynamic range rendering.
+		 * @param[in]	numSamples		Number of samples to use if multisampling is active. Provide 0 or 1 if multisampled
+		 *								targets are not needed.
 		 */
 		static SPtr<RenderTargets> create(const SPtr<ViewportCore>& viewport, bool hdr, UINT32 numSamples);
 
 		/**
-		 * @brief	Allocates the textures required for rendering. Allocations are pooled so this is generally a fast 
-		 * 			operation unless the size or other render target options changed. This must be called before binding
-		 * 			render targets.
+		 * Allocates the textures required for rendering. Allocations are pooled so this is generally a fast operation
+		 * unless the size or other render target options changed. This must be called before binding render targets.
 		 */
 		void allocate();
 
 		/**
-		 * @brief	Deallocates textures by returning them to the pool. This should be done when the caller is done using 
-		 * 			the render targets, so that other systems might re-use them. This will not release any memory unless
-		 * 			all render targets pointing to those textures go out of scope.
+		 * Deallocates textures by returning them to the pool. This should be done when the caller is done using the render
+		 * targets, so that other systems might re-use them. This will not release any memory unless all render targets
+		 * pointing to those textures go out of scope.
 		 */
 		void release();
 
-		/**
-		 * @brief	Binds the GBuffer render target for rendering.
-		 */
+		/**	Binds the GBuffer render target for rendering. */
 		void bindGBuffer();
 
-		/**
-		 * @brief	Binds the scene color render target for rendering.
-		 */
+		/**	Binds the scene color render target for rendering. */
 		void bindSceneColor(bool readOnlyDepthStencil);
 
-		/**
-		 * @brief	Resolves the GBuffer scene color into the output scene color buffer.
-		 */
+		/**	Resolves the GBuffer scene color into the output scene color buffer. */
 		void resolve();
 
-		/**
-		 * @brief	Returns the first color texture of the gbuffer as a bindable texture.
-		 */
+		/**	Returns the first color texture of the gbuffer as a bindable texture. */
 		SPtr<TextureCore> getTextureA() const;
 
-		/**
-		* @brief	Returns the second color texture of the gbuffer as a bindable texture.
-		*/
+		/**	Returns the second color texture of the gbuffer as a bindable texture. */
 		SPtr<TextureCore> getTextureB() const;
 
-		/**
-		 * @brief	Returns the depth texture of the gbuffer as a bindable texture.
-		 */
+		/**	Returns the depth texture of the gbuffer as a bindable texture. */
 		SPtr<TextureCore> getTextureDepth() const;
 
-		/**
-		 * @brief	Checks if the targets support HDR rendering.
-		 */
+		/**	Checks if the targets support HDR rendering. */
 		bool getHDR() const { return mHDR; }
 
-		/**
-		 * @brief	Returns the number of samples per pixel supported by the targets.
-		 */
+		/**	Returns the number of samples per pixel supported by the targets. */
 		UINT32 getNumSamples() const { return mNumSamples; }
 
 	private:
 		RenderTargets(const SPtr<ViewportCore>& viewport, bool hdr, UINT32 numSamples);
 
-		/**
-		 * @brief	Returns the width of gbuffer textures, in pixels.
-		 */
+		/**	Returns the width of gbuffer textures, in pixels. */
 		UINT32 getWidth() const;
 
-		/**
-		 * @brief	Returns the height of gbuffer textures, in pixels.
-		 */
+		/**	Returns the height of gbuffer textures, in pixels. */
 		UINT32 getHeight() const;
 
 		SPtr<ViewportCore> mViewport;
@@ -110,4 +92,6 @@ namespace BansheeEngine
 		UINT32 mNumSamples;
 		bool mHDR;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsRenderTexturePool.h

@@ -8,11 +8,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	class RenderTexturePool;
 
-	/**
-	 * @brief	Contains data about a single render texture in the texture pool.
-	 */
+	/**	Contains data about a single render texture in the texture pool. */
 	struct PooledRenderTexture
 	{
 		PooledRenderTexture(RenderTexturePool* pool);
@@ -27,60 +29,59 @@ namespace BansheeEngine
 		bool mIsFree;
 	};
 
-	/**
-	 * @brief	Contains a pool of render textures meant to accommodate reuse of
-	 *			render textures of the same size and format.
-	 */
+	/** Contains a pool of render textures meant to accommodate reuse of render textures of the same size and format. */
 	class RenderTexturePool : public Module<RenderTexturePool>
 	{
 	public:
 		~RenderTexturePool();
 
 		/**
-		 * @brief	Attempts to find the unused render texture with the specified parameters in the pool, 
-		 *			or creates a new texture otherwise. When done with the texture make sure to call ::free.
+		 * Attempts to find the unused render texture with the specified parameters in the pool, or creates a new texture
+		 * otherwise. When done with the texture make sure to call release().
 		 *
-		 * @param	format				Pixel format used by the texture color surface.
-		 * @param	width				Width of the render texture, in pixels.
-		 * @param	height				Height of the render texture, in pixels.
-		 * @param	hwGamma				Should the written pixels be gamma corrected.
-		 * @param	samples				If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param[in]	format		Pixel format used by the texture color surface.
+		 * @param[in]	width		Width of the render texture, in pixels.
+		 * @param[in]	height		Height of the render texture, in pixels.
+		 * @param[in]	hwGamma		Should the written pixels be gamma corrected.
+		 * @param[in]	samples		If higher than 1, texture containing multiple samples per pixel is created.
 		 */
-		SPtr<PooledRenderTexture> get(PixelFormat format, UINT32 width, UINT32 height, bool hwGamma = false, UINT32 samples = 0);
+		SPtr<PooledRenderTexture> get(PixelFormat format, UINT32 width, UINT32 height, bool hwGamma = false, 
+			UINT32 samples = 0);
 
 		/**
-		 * @brief	Releases a texture previously allocated with ::get. The texture is returned to the pool so that it may be reused later.
+		 * Releases a texture previously allocated with get(). The texture is returned to the pool so that it may be reused
+		 * later.
 		 *			
-		 * @note	The texture will be removed from the pool if the last reference to it is deleted. Normally you would call ::release but
-		 *			keep a reference if you plan on using it later on.
+		 * @note	
+		 * The texture will be removed from the pool if the last reference to it is deleted. Normally you would call 
+		 * release() but keep a reference if you plan on using it later on.
 		 */
 		void release(const SPtr<PooledRenderTexture>& texture);
 
 	private:
 		friend struct PooledRenderTexture;
 
-		/**
-		 * @brief	Registers a newly created render texture in the pool.
-		 */
+		/**	Registers a newly created render texture in the pool. */
 		void _registerTexture(const SPtr<PooledRenderTexture>& texture);
 
-		/**
-		 * @brief	Unregisters a created render texture in the pool.
-		 */
+		/**	Unregisters a created render texture in the pool. */
 		void _unregisterTexture(PooledRenderTexture* texture);
 
 		/**
-		 * @brief	Checks does the provided texture match the parameters.
+		 * Checks does the provided texture match the parameters.
 		 * 
-		 * @param	texture		Texture to match against the parameters.
-		 * @param	format		Pixel format used by the texture color surface.
-		 * @param	width		Width of the render texture, in pixels.
-		 * @param	height		Height of the render texture, in pixels.
-		 * @param	hwGamma		Should the written pixels be gamma corrected.
-		 * @param	samples		If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param[in]	texture		Texture to match against the parameters.
+		 * @param[in]	format		Pixel format used by the texture color surface.
+		 * @param[in]	width		Width of the render texture, in pixels.
+		 * @param[in]	height		Height of the render texture, in pixels.
+		 * @param[in]	hwGamma		Should the written pixels be gamma corrected.
+		 * @param[in]	samples		If higher than 1, texture containing multiple samples per pixel is created.
 		 */
-		bool matches(const SPtr<TextureCore>& texture, PixelFormat format, UINT32 width, UINT32 height, bool hwGamma, UINT32 samples);
+		bool matches(const SPtr<TextureCore>& texture, PixelFormat format, UINT32 width, UINT32 height, bool hwGamma,
+			UINT32 samples);
 
 		Map<PooledRenderTexture*, std::weak_ptr<PooledRenderTexture>> mTextures;
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsSamplerOverrides.h

@@ -6,27 +6,25 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains data about an overridden sampler states for a single pass stage.
+	/** @addtogroup RenderBeast
+	 *  @{
 	 */
+
+	/**	Contains data about an overridden sampler states for a single pass stage. */
 	struct StageSamplerOverrides
 	{
 		SPtr<SamplerStateCore>* stateOverrides;
 		UINT32 numStates;
 	};
 
-	/**
-	 * @brief	Contains data about an overridden sampler states for a single pass.
-	 */
+	/**	Contains data about an overridden sampler states for a single pass. */
 	struct PassSamplerOverrides
 	{
 		StageSamplerOverrides* stages;
 		UINT32 numStages;
 	};
 
-	/**
-	 * @brief	Contains data about an overridden sampler states in the entire material.
-	 */
+	/**	Contains data about an overridden sampler states in the entire material. */
 	struct MaterialSamplerOverrides
 	{
 		PassSamplerOverrides* passes;
@@ -34,33 +32,34 @@ namespace BansheeEngine
 		UINT32 refCount;
 	};
 
-	/**
-	 * @brief	Helper class for generating sampler overrides.
-	 */
+	/**	Helper class for generating sampler overrides. */
 	class BS_BSRND_EXPORT SamplerOverrideUtility
 	{
 	public:
 		/**
-		 * @brief	Generates a set of sampler overrides for the specified material. Overrides are
-		 *			generates according to the provided render options. 
+		 * Generates a set of sampler overrides for the specified material. Overrides are generates according to the
+		 * provided render options. 
 		 */
-		static MaterialSamplerOverrides* generateSamplerOverrides(const SPtr<MaterialCore>& material, const SPtr<RenderBeastOptions>& options);
+		static MaterialSamplerOverrides* generateSamplerOverrides(const SPtr<MaterialCore>& material, 
+			const SPtr<RenderBeastOptions>& options);
 
-		/**
-		 * @brief	Destroys sampler overrides previously generated with ::generateSamplerOverrides.
-		 */
+		/**	Destroys sampler overrides previously generated with generateSamplerOverrides(). */
 		static void destroySamplerOverrides(MaterialSamplerOverrides* overrides);
 
 		/**
-		 * @brief	Checks if the provided sampler state requires an override, in case the render options have
-		 *			requirements not fulfilled by current sampler state (e.g. filtering type).
+		 * Checks if the provided sampler state requires an override, in case the render options have requirements not
+		 * fulfilled by current sampler state (e.g. filtering type).
 		 */
-		static bool checkNeedsOverride(const SPtr<SamplerStateCore>& samplerState, const SPtr<RenderBeastOptions>& options);
+		static bool checkNeedsOverride(const SPtr<SamplerStateCore>& samplerState, 
+			const SPtr<RenderBeastOptions>& options);
 
 		/**
-		 * @brief	Generates a new sampler state override using the provided state as the basis. Overridden properties
-		 *			are taken from the provided render options.
+		 * Generates a new sampler state override using the provided state as the basis. Overridden properties are taken
+		 * from the provided render options.
 		 */
-		static SPtr<SamplerStateCore> generateSamplerOverride(const SPtr<SamplerStateCore>& samplerState, const SPtr<RenderBeastOptions>& options);
+		static SPtr<SamplerStateCore> generateSamplerOverride(const SPtr<SamplerStateCore>& samplerState, 
+			const SPtr<RenderBeastOptions>& options);
 	};
+
+	/** @} */
 }

RenderBeast/Include/BsStaticRenderableHandler.h

@@ -12,6 +12,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup RenderBeast
+	 *  @{
+	 */
+
 	BS_PARAM_BLOCK_BEGIN(PerFrameParamBuffer)
 		BS_PARAM_BLOCK_ENTRY(float, gTime)
 	BS_PARAM_BLOCK_END
@@ -78,4 +82,6 @@ namespace BansheeEngine
 		PerCameraParamBuffer mPerCameraParams;
 		PerObjectParamBuffer mPerObjectParams;
 	};
+
+	/** @} */
 }