More work on preparing documentation for Doxygen generation

BansheeCore/Include/BsCoreObject.h

@@ -86,6 +86,7 @@ namespace BansheeEngine
 		 */
 		void syncToCore(CoreAccessor& accessor);
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsCoreObjectCore.h

@@ -37,6 +37,7 @@ namespace BansheeEngine
 		/** Returns a shared_ptr version of "this" pointer. */
 		SPtr<CoreObjectCore> getThisPtr() const { return mThis.lock(); }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsCoreRenderer.h

@@ -1,142 +1,142 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#pragma once
-
-#include "BsCorePrerequisites.h"
-#include "BsStringID.h"
-#include "BsRendererMeshData.h"
-
-namespace BansheeEngine
-{
-	/** @cond INTERNAL */
+#pragma once
+
+#include "BsCorePrerequisites.h"
+#include "BsStringID.h"
+#include "BsRendererMeshData.h"
+
+namespace BansheeEngine
+{
+	/** @cond INTERNAL */
 	/** @addtogroup Renderer
 	 *  @{
-	 */
-
-	/**
-	 * Available parameter block semantics that allow the renderer to identify the use of a GPU program parameter block 
-	 * specified in a shader.
-	 */
-	static StringID RBS_Static = "Static";
-	static StringID RBS_PerCamera = "PerCamera";
-	static StringID RBS_PerFrame = "PerFrame";
-	static StringID RBS_PerObject = "PerObject";
-
-	/**
-	 * Available parameter semantics that allow the renderer to identify the use of a GPU parameter specified in a shader.
-	 */
-	static StringID RPS_WorldViewProjTfrm = "WVP";
-	static StringID RPS_ViewProjTfrm = "VP";
-	static StringID RPS_ProjTfrm = "P";
-	static StringID RPS_ViewTfrm = "V";
-	static StringID RPS_WorldTfrm = "W";
-	static StringID RPS_InvWorldTfrm = "IW";
-	static StringID RPS_WorldNoScaleTfrm = "WNoScale";
-	static StringID RPS_InvWorldNoScaleTfrm = "IWNoScale";
-	static StringID RPS_WorldDeterminantSign = "WorldDeterminantSign";
-	static StringID RPS_Diffuse = "Diffuse";
-	static StringID RPS_ViewDir = "ViewDir";
-
-	/**	Set of options that can be used for controlling the renderer. */	
-	struct BS_CORE_EXPORT CoreRendererOptions
-	{
-		virtual ~CoreRendererOptions() { }
-	};
-
-	/**
-	 * Primarily rendering class that allows you to specify how to render objects that exist in the scene graph. You need
-	 * to provide your own implementation of your class.
-	 *
-	 * @note	
-	 * Normally you would iterate over all cameras, find visible objects for each camera and render those objects in some way.
-	 */
-	class BS_CORE_EXPORT CoreRenderer
-	{
-	public:
-		CoreRenderer();
-		virtual ~CoreRenderer() { }
-
-		/** Initializes the renderer. Must be called before using the renderer. */
-		virtual void initialize() { }
-
-		/**	Cleans up the renderer. Must be called before the renderer is deleted. */
-		virtual void destroy() { }
-
-		/** Name of the renderer. Used by materials to find an appropriate technique for this renderer. */
-		virtual const StringID& getName() const = 0;
-
-		/** Called in order to render all currently active cameras. */
-		virtual void renderAll() = 0;
-
-		/**
-		 * Called whenever a new camera is created.
-		 *
-		 * @note	Core thread.
-		 */
-		virtual void _notifyCameraAdded(const CameraCore* camera) { }
-
-		/**
-		 * Called whenever a camera is destroyed.
-		 *
-		 * @note	Core thread.
-		 */
-		virtual void _notifyCameraRemoved(const CameraCore* camera) { }
-
-		/**
-		 * Creates a new empty renderer mesh data.
-		 *
-		 * @note	Sim thread.
-		 *			
-		 * @see		RendererMeshData
-		 */
-		virtual RendererMeshDataPtr _createMeshData(UINT32 numVertices, UINT32 numIndices, VertexLayout layout, IndexType indexType = IT_32BIT);
-
-		/**
-		 * Creates a new renderer mesh data using an existing generic mesh data buffer.
-		 *
-		 * @note	Sim thread.
-		 *			
-		 * @see		RendererMeshData
-		 */
-		virtual RendererMeshDataPtr _createMeshData(const MeshDataPtr& meshData);
-
-		/**
-		 * Registers a new callback that will be executed when the the specify camera is being rendered.
-		 *
-		 * @param[in]	camera		Camera for which to trigger the callback.
-		 * @param[in]	index		Index that determines the order of rendering when there are multiple registered 
-		 *							callbacks. This must be unique. Lower indices get rendered sooner. Indices below 0 get 
-		 *							rendered before the main viewport elements, while indices equal or greater to zero after. 
-		 * @param[in]	callback	Callback to trigger when the specified camera is being rendered.
-		 * @param[in]	isOverlay	If true the render callback guarantees that it will only render overlay data. Overlay 
-		 *							data doesn't require a depth buffer, a multisampled render target and is usually cheaper
-		 *							to render (although this depends on the exact renderer). 
-		 *							Overlay callbacks are always rendered after all other callbacks, even if their index is negative.
-		 *
-		 * @note	Core thread.
-		 */
-		void _registerRenderCallback(const CameraCore* camera, INT32 index, const std::function<void()>& callback, bool isOverlay = false);
-
-		/** Removes a previously registered callback registered with _registerRenderCallback(). */
-		void _unregisterRenderCallback(const CameraCore* camera, INT32 index);
-
-		/**	Sets options used for controlling the rendering. */
-		virtual void setOptions(const SPtr<CoreRendererOptions>& options) { }
-
-		/**	Returns current set of options used for controlling the rendering. */
-		virtual SPtr<CoreRendererOptions> getOptions() const { return SPtr<CoreRendererOptions>(); }
-
-	protected:
-		/**	Contains information about a render callback. */
-		struct RenderCallbackData
-		{
-			bool overlay;
-			std::function<void()> callback;
-		};
-
-		UnorderedMap<const CameraCore*, Map<INT32, RenderCallbackData>> mRenderCallbacks;
-	};
-
-	/** @} */
-	/** @endcond */
+	 */
+
+	/**
+	 * Available parameter block semantics that allow the renderer to identify the use of a GPU program parameter block 
+	 * specified in a shader.
+	 */
+	static StringID RBS_Static = "Static";
+	static StringID RBS_PerCamera = "PerCamera";
+	static StringID RBS_PerFrame = "PerFrame";
+	static StringID RBS_PerObject = "PerObject";
+
+	/**
+	 * Available parameter semantics that allow the renderer to identify the use of a GPU parameter specified in a shader.
+	 */
+	static StringID RPS_WorldViewProjTfrm = "WVP";
+	static StringID RPS_ViewProjTfrm = "VP";
+	static StringID RPS_ProjTfrm = "P";
+	static StringID RPS_ViewTfrm = "V";
+	static StringID RPS_WorldTfrm = "W";
+	static StringID RPS_InvWorldTfrm = "IW";
+	static StringID RPS_WorldNoScaleTfrm = "WNoScale";
+	static StringID RPS_InvWorldNoScaleTfrm = "IWNoScale";
+	static StringID RPS_WorldDeterminantSign = "WorldDeterminantSign";
+	static StringID RPS_Diffuse = "Diffuse";
+	static StringID RPS_ViewDir = "ViewDir";
+
+	/**	Set of options that can be used for controlling the renderer. */	
+	struct BS_CORE_EXPORT CoreRendererOptions
+	{
+		virtual ~CoreRendererOptions() { }
+	};
+
+	/**
+	 * Primarily rendering class that allows you to specify how to render objects that exist in the scene graph. You need
+	 * to provide your own implementation of your class.
+	 *
+	 * @note	
+	 * Normally you would iterate over all cameras, find visible objects for each camera and render those objects in some way.
+	 */
+	class BS_CORE_EXPORT CoreRenderer
+	{
+	public:
+		CoreRenderer();
+		virtual ~CoreRenderer() { }
+
+		/** Initializes the renderer. Must be called before using the renderer. */
+		virtual void initialize() { }
+
+		/**	Cleans up the renderer. Must be called before the renderer is deleted. */
+		virtual void destroy() { }
+
+		/** Name of the renderer. Used by materials to find an appropriate technique for this renderer. */
+		virtual const StringID& getName() const = 0;
+
+		/** Called in order to render all currently active cameras. */
+		virtual void renderAll() = 0;
+
+		/**
+		 * Called whenever a new camera is created.
+		 *
+		 * @note	Core thread.
+		 */
+		virtual void _notifyCameraAdded(const CameraCore* camera) { }
+
+		/**
+		 * Called whenever a camera is destroyed.
+		 *
+		 * @note	Core thread.
+		 */
+		virtual void _notifyCameraRemoved(const CameraCore* camera) { }
+
+		/**
+		 * Creates a new empty renderer mesh data.
+		 *
+		 * @note	Sim thread.
+		 *			
+		 * @see		RendererMeshData
+		 */
+		virtual RendererMeshDataPtr _createMeshData(UINT32 numVertices, UINT32 numIndices, VertexLayout layout, IndexType indexType = IT_32BIT);
+
+		/**
+		 * Creates a new renderer mesh data using an existing generic mesh data buffer.
+		 *
+		 * @note	Sim thread.
+		 *			
+		 * @see		RendererMeshData
+		 */
+		virtual RendererMeshDataPtr _createMeshData(const MeshDataPtr& meshData);
+
+		/**
+		 * Registers a new callback that will be executed when the the specify camera is being rendered.
+		 *
+		 * @param[in]	camera		Camera for which to trigger the callback.
+		 * @param[in]	index		Index that determines the order of rendering when there are multiple registered 
+		 *							callbacks. This must be unique. Lower indices get rendered sooner. Indices below 0 get 
+		 *							rendered before the main viewport elements, while indices equal or greater to zero after. 
+		 * @param[in]	callback	Callback to trigger when the specified camera is being rendered.
+		 * @param[in]	isOverlay	If true the render callback guarantees that it will only render overlay data. Overlay 
+		 *							data doesn't require a depth buffer, a multisampled render target and is usually cheaper
+		 *							to render (although this depends on the exact renderer). 
+		 *							Overlay callbacks are always rendered after all other callbacks, even if their index is negative.
+		 *
+		 * @note	Core thread.
+		 */
+		void _registerRenderCallback(const CameraCore* camera, INT32 index, const std::function<void()>& callback, bool isOverlay = false);
+
+		/** Removes a previously registered callback registered with _registerRenderCallback(). */
+		void _unregisterRenderCallback(const CameraCore* camera, INT32 index);
+
+		/**	Sets options used for controlling the rendering. */
+		virtual void setOptions(const SPtr<CoreRendererOptions>& options) { }
+
+		/**	Returns current set of options used for controlling the rendering. */
+		virtual SPtr<CoreRendererOptions> getOptions() const { return SPtr<CoreRendererOptions>(); }
+
+	protected:
+		/**	Contains information about a render callback. */
+		struct RenderCallbackData
+		{
+			bool overlay;
+			std::function<void()> callback;
+		};
+
+		UnorderedMap<const CameraCore*, Map<INT32, RenderCallbackData>> mRenderCallbacks;
+	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeCore/Include/BsFont.h

@@ -43,17 +43,6 @@ namespace BansheeEngine
 	public:
 		virtual ~Font();
 
-		/** @cond INTERNAL */
-
-		/**
-		 * Initializes the font with specified per-size font data.
-		 *
-		 * @note	Internal method. Factory methods will call this automatically for you.
-		 */
-		void initialize(const Vector<SPtr<FontBitmap>>& fontData);
-
-		/** @endcond */
-
 		/**
 		 * Returns font bitmap for a specific size if it exists, null otherwise.
 		 *
@@ -67,8 +56,16 @@ namespace BansheeEngine
 		/**	Creates a new font from the provided per-size font data. */
 		static HFont create(const Vector<SPtr<FontBitmap>>& fontInitData);
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
+		/**
+		 * Initializes the font with specified per-size font data.
+		 *
+		 * @note	Internal method. Factory methods will call this automatically for you.
+		 */
+		void initialize(const Vector<SPtr<FontBitmap>>& fontData);
+
 		/** Creates a new font as a pointer instead of a resource handle. */
 		static FontPtr _createPtr(const Vector<SPtr<FontBitmap>>& fontInitData);
 

BansheeCore/Include/BsGameObject.h

@@ -53,6 +53,7 @@ namespace BansheeEngine
 		/**	Sets the name of the object. */
 		void setName(const String& name) { mName = name; }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsGameObjectHandle.h

@@ -101,6 +101,7 @@ namespace BansheeEngine
 		 */
 		GameObject& operator*() const { return *get(); }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** Returns internal handle data. */
@@ -239,6 +240,7 @@ namespace BansheeEngine
 		 */
 		T& operator*() const { return *get(); }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		template<class _Ty>

BansheeCore/Include/BsInput.h

@@ -128,6 +128,32 @@ namespace BansheeEngine
 		/** Enables or disables mouse smoothing. Smoothing makes the changes to mouse axes more gradual. */
 		void setMouseSmoothing(bool enabled);
 
+		/** Triggered whenever a button is first pressed. */
+		Event<void(const ButtonEvent&)> onButtonDown;
+
+		/**	Triggered whenever a button is first released. */
+		Event<void(const ButtonEvent&)> onButtonUp;
+
+		/**	Triggered whenever user inputs a text character. */
+		Event<void(const TextInputEvent&)> onCharInput;
+
+		/**	Triggers when some pointing device (mouse cursor, touch) moves. */
+		Event<void(const PointerEvent&)> onPointerMoved;
+
+		/**	Triggers when some pointing device (mouse cursor, touch) button is pressed. */
+		Event<void(const PointerEvent&)> onPointerPressed;
+
+		/**	Triggers when some pointing device (mouse cursor, touch) button is released. */
+		Event<void(const PointerEvent&)> onPointerReleased;
+
+		/**	Triggers when some pointing device (mouse cursor, touch) button is double clicked. */
+		Event<void(const PointerEvent&)> onPointerDoubleClick;
+
+		// TODO Low priority: Remove this, I can emulate it using virtual input
+		/**	Triggers on special input commands. */
+		Event<void(InputCommandType)> onInputCommand;
+
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**
@@ -154,31 +180,6 @@ namespace BansheeEngine
 
 		/** @endcond */
 
-		/** Triggered whenever a button is first pressed. */
-		Event<void(const ButtonEvent&)> onButtonDown;
-
-		/**	Triggered whenever a button is first released. */
-		Event<void(const ButtonEvent&)> onButtonUp;
-
-		/**	Triggered whenever user inputs a text character. */
-		Event<void(const TextInputEvent&)> onCharInput;
-
-		/**	Triggers when some pointing device (mouse cursor, touch) moves. */
-		Event<void(const PointerEvent&)> onPointerMoved;
-
-		/**	Triggers when some pointing device (mouse cursor, touch) button is pressed. */
-		Event<void(const PointerEvent&)> onPointerPressed;
-
-		/**	Triggers when some pointing device (mouse cursor, touch) button is released. */
-		Event<void(const PointerEvent&)> onPointerReleased;
-
-		/**	Triggers when some pointing device (mouse cursor, touch) button is double clicked. */
-		Event<void(const PointerEvent&)> onPointerDoubleClick;
-
-		// TODO Low priority: Remove this, I can emulate it using virtual input
-		/**	Triggers on special input commands. */
-		Event<void(InputCommandType)> onInputCommand;
-
 	private:
 		/**	Triggered by input handler when a button is pressed. */
 		void buttonDown(UINT32 deviceIdx, ButtonCode code, UINT64 timestamp);

BansheeCore/Include/BsMultiRenderTexture.h

@@ -1,143 +1,143 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#pragma once
-
-#include "BsCorePrerequisites.h"
-#include "BsRenderTarget.h"
-
-namespace BansheeEngine
-{
+#pragma once
+
+#include "BsCorePrerequisites.h"
+#include "BsRenderTarget.h"
+
+namespace BansheeEngine
+{
 	/** @addtogroup RenderAPI
 	 *  @{
-	 */
-
-	/**
-	 * Descriptor class used for initializing a MultiRenderTexture. Contains descriptors for each individual color render 
-	 * surface and their common depth/stencil surface.
-	 */
-	struct BS_CORE_EXPORT MULTI_RENDER_TEXTURE_DESC
-	{
-		Vector<RENDER_SURFACE_DESC> colorSurfaces;
-		RENDER_SURFACE_DESC depthStencilSurface;
-	};
-
-	/**
-	 * @see		MULTI_RENDER_TEXTURE_DESC
-	 *
-	 * @note	References core textures instead of texture handles.
-	 */
-	struct BS_CORE_EXPORT MULTI_RENDER_TEXTURE_CORE_DESC
-	{
-		Vector<RENDER_SURFACE_CORE_DESC> colorSurfaces;
-		RENDER_SURFACE_CORE_DESC depthStencilSurface;
-	};
-
-	/** Contains various properties that describe a render texture. */
-	class BS_CORE_EXPORT MultiRenderTextureProperties : public RenderTargetProperties
-	{
-	public:
-		MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_DESC& desc);
-		MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_CORE_DESC& desc);
-		virtual ~MultiRenderTextureProperties() { }
-
-	protected:
-		friend class MultiRenderTextureCore;
-		friend class MultiRenderTexture;
-
-		void construct(const TextureProperties* props);
-	};
-
-	/** @cond INTERNAL */
-
-	/**
-	 * Object representing multiple render textures. You may bind this to the pipeline in order to render to all or some 
-	 * of the textures at once.
-	 *
-	 * @note	Core thread only.
-	 */
-	class BS_CORE_EXPORT MultiRenderTextureCore : public RenderTargetCore
-	{
-	public:
-		virtual ~MultiRenderTextureCore();
-
-		/** @copydoc CoreObjectCore::initialize */
-		virtual void initialize() override;
-
-		/** Returns properties that describe the render texture. */
-		const MultiRenderTextureProperties& getProperties() const;
-
-	protected:
-		MultiRenderTextureCore(const MULTI_RENDER_TEXTURE_CORE_DESC& desc);
-
-		/** @copydoc CoreObjectCore::syncToCore */
-		virtual void syncToCore(const CoreSyncData& data) override;
-
-	private:
-		/** Checks that all render surfaces and depth/stencil surface match. If they do not match an exception is thrown. */
-		void throwIfBuffersDontMatch() const;
-
-		// TODO - Not implemented
-		virtual void copyToMemory(PixelData &dst, FrameBuffer buffer = FB_AUTO);
-
-	protected:
-		Vector<TextureViewPtr> mColorSurfaces;
-		TextureViewPtr mDepthStencilSurface;
-
-		MULTI_RENDER_TEXTURE_CORE_DESC mDesc;
-	};
-
-	/** @endcond */
-
-	/**
-	 * Object representing multiple render textures. You may bind this to the pipeline in order to render to all or some of 
-	 * the textures at once.
-	 *
-	 * @note	Sim thread only.
-	 */
-	class BS_CORE_EXPORT MultiRenderTexture : public RenderTarget
-	{
-	public:
-		virtual ~MultiRenderTexture() { }
-
-		/**
-		 * Returns a color surface texture you may bind as an input to an GPU program.
-		 *
-		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
-		 */
-		const HTexture& getBindableColorTexture(UINT32 idx) const { return mBindableColorTex[idx]; }
-
-		/**
-		 * Returns a depth/stencil surface texture you may bind as an input to an GPU program.
-		 *
-		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
-		 */
-		const HTexture& getBindableDepthStencilTexture() const { return mBindableDepthStencilTex; }
-
-		/** Retrieves a core implementation of a render texture usable only from the core thread. */
-		SPtr<MultiRenderTextureCore> getCore() const;
-
-		/** @copydoc TextureManager::createMultiRenderTexture */
-		static MultiRenderTexturePtr create(const MULTI_RENDER_TEXTURE_DESC& desc);
-
-		/**	Returns properties that describe the render texture. */
-		const MultiRenderTextureProperties& getProperties() const;
-
-		/**	Returns the number of color surfaces used by the render texture. */
-		UINT32 getColorSurfaceCount() const;
-
-	protected:
-		MultiRenderTexture(const MULTI_RENDER_TEXTURE_DESC& desc);
-
-		/** @copydoc RenderTarget::createCore */
-		SPtr<CoreObjectCore> createCore() const override;
-
-		/** @copydoc CoreObjectCore::syncToCore */
-		virtual CoreSyncData syncToCore(FrameAlloc* allocator) override;
-
-		MULTI_RENDER_TEXTURE_DESC mDesc;
-		Vector<HTexture> mBindableColorTex;
-		HTexture mBindableDepthStencilTex;
-	};
-
-	/** @} */
+	 */
+
+	/**
+	 * Descriptor class used for initializing a MultiRenderTexture. Contains descriptors for each individual color render 
+	 * surface and their common depth/stencil surface.
+	 */
+	struct BS_CORE_EXPORT MULTI_RENDER_TEXTURE_DESC
+	{
+		Vector<RENDER_SURFACE_DESC> colorSurfaces;
+		RENDER_SURFACE_DESC depthStencilSurface;
+	};
+
+	/**
+	 * @see		MULTI_RENDER_TEXTURE_DESC
+	 *
+	 * @note	References core textures instead of texture handles.
+	 */
+	struct BS_CORE_EXPORT MULTI_RENDER_TEXTURE_CORE_DESC
+	{
+		Vector<RENDER_SURFACE_CORE_DESC> colorSurfaces;
+		RENDER_SURFACE_CORE_DESC depthStencilSurface;
+	};
+
+	/** Contains various properties that describe a render texture. */
+	class BS_CORE_EXPORT MultiRenderTextureProperties : public RenderTargetProperties
+	{
+	public:
+		MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_DESC& desc);
+		MultiRenderTextureProperties(const MULTI_RENDER_TEXTURE_CORE_DESC& desc);
+		virtual ~MultiRenderTextureProperties() { }
+
+	protected:
+		friend class MultiRenderTextureCore;
+		friend class MultiRenderTexture;
+
+		void construct(const TextureProperties* props);
+	};
+
+	/** @cond INTERNAL */
+
+	/**
+	 * Object representing multiple render textures. You may bind this to the pipeline in order to render to all or some 
+	 * of the textures at once.
+	 *
+	 * @note	Core thread only.
+	 */
+	class BS_CORE_EXPORT MultiRenderTextureCore : public RenderTargetCore
+	{
+	public:
+		virtual ~MultiRenderTextureCore();
+
+		/** @copydoc CoreObjectCore::initialize */
+		virtual void initialize() override;
+
+		/** Returns properties that describe the render texture. */
+		const MultiRenderTextureProperties& getProperties() const;
+
+	protected:
+		MultiRenderTextureCore(const MULTI_RENDER_TEXTURE_CORE_DESC& desc);
+
+		/** @copydoc CoreObjectCore::syncToCore */
+		virtual void syncToCore(const CoreSyncData& data) override;
+
+	private:
+		/** Checks that all render surfaces and depth/stencil surface match. If they do not match an exception is thrown. */
+		void throwIfBuffersDontMatch() const;
+
+		// TODO - Not implemented
+		virtual void copyToMemory(PixelData &dst, FrameBuffer buffer = FB_AUTO);
+
+	protected:
+		Vector<TextureViewPtr> mColorSurfaces;
+		TextureViewPtr mDepthStencilSurface;
+
+		MULTI_RENDER_TEXTURE_CORE_DESC mDesc;
+	};
+
+	/** @endcond */
+
+	/**
+	 * Object representing multiple render textures. You may bind this to the pipeline in order to render to all or some of 
+	 * the textures at once.
+	 *
+	 * @note	Sim thread only.
+	 */
+	class BS_CORE_EXPORT MultiRenderTexture : public RenderTarget
+	{
+	public:
+		virtual ~MultiRenderTexture() { }
+
+		/**
+		 * Returns a color surface texture you may bind as an input to an GPU program.
+		 *
+		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
+		 */
+		const HTexture& getBindableColorTexture(UINT32 idx) const { return mBindableColorTex[idx]; }
+
+		/**
+		 * Returns a depth/stencil surface texture you may bind as an input to an GPU program.
+		 *
+		 * @note	Be aware that you cannot bind a render texture for reading and writing at the same time.
+		 */
+		const HTexture& getBindableDepthStencilTexture() const { return mBindableDepthStencilTex; }
+
+		/** Retrieves a core implementation of a render texture usable only from the core thread. */
+		SPtr<MultiRenderTextureCore> getCore() const;
+
+		/** @copydoc TextureManager::createMultiRenderTexture */
+		static MultiRenderTexturePtr create(const MULTI_RENDER_TEXTURE_DESC& desc);
+
+		/**	Returns properties that describe the render texture. */
+		const MultiRenderTextureProperties& getProperties() const;
+
+		/**	Returns the number of color surfaces used by the render texture. */
+		UINT32 getColorSurfaceCount() const;
+
+	protected:
+		MultiRenderTexture(const MULTI_RENDER_TEXTURE_DESC& desc);
+
+		/** @copydoc RenderTarget::createCore */
+		SPtr<CoreObjectCore> createCore() const override;
+
+		/** @copydoc CoreObjectCore::syncToCore */
+		virtual CoreSyncData syncToCore(FrameAlloc* allocator) override;
+
+		MULTI_RENDER_TEXTURE_DESC mDesc;
+		Vector<HTexture> mBindableColorTex;
+		HTexture mBindableDepthStencilTex;
+	};
+
+	/** @} */
 }

BansheeCore/Include/BsPrefab.h

@@ -48,6 +48,7 @@ namespace BansheeEngine
 		 */
 		UINT32 getHash() const { return mHash; }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** Updates any prefab child instances by loading their prefabs and making sure they are up to date. */

BansheeCore/Include/BsProfilerGPU.h

@@ -130,6 +130,7 @@ namespace BansheeEngine
 		 */
 		GPUProfilerReport getNextReport();
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsResourceHandle.h

@@ -64,6 +64,7 @@ namespace BansheeEngine
 		/** Returns the UUID of the resource the handle is referring to. */
 		const String& getUUID() const { return mData != nullptr ? mData->mUUID : StringUtil::BLANK; }
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**	Gets the handle data. For internal use only. */

BansheeCore/Include/BsResources.h

@@ -238,20 +238,6 @@ namespace BansheeEngine
 		/** Attempts to retrieve UUID from the provided file path. Returns true if successful, false otherwise. */
 		bool getUUIDFromFilePath(const Path& path, String& uuid) const;
 
-		/** @cond INTERNAL */
-
-		/**
-		 * Creates a new resource handle from a resource pointer. 
-		 *
-		 * @note	Internal method used primarily be resource factory methods.
-		 */
-		HResource _createResourceHandle(const ResourcePtr& obj);
-
-		/** Returns an existing handle for the specified UUID if one exists, or creates a new one. */
-		HResource _getResourceHandle(const String& uuid);
-
-		/** @endcond */
-
 		/**
 		 * Called when the resource has been successfully loaded. 
 		 *
@@ -274,6 +260,21 @@ namespace BansheeEngine
 		 * @note	It is undefined from which thread this will get called from.
 		 */
 		Event<void(const HResource&)> onResourceModified;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/**
+		 * Creates a new resource handle from a resource pointer. 
+		 *
+		 * @note	Internal method used primarily be resource factory methods.
+		 */
+		HResource _createResourceHandle(const ResourcePtr& obj);
+
+		/** Returns an existing handle for the specified UUID if one exists, or creates a new one. */
+		HResource _getResourceHandle(const String& uuid);
+
+		/** @endcond */
 	private:
 		friend class ResourceHandleBase;
 

BansheeCore/Include/BsSceneObject.h

@@ -95,6 +95,7 @@ namespace BansheeEngine
 		/**	Checks if the scene object has a specific bit flag set. */
 		bool hasFlag(UINT32 flag) const;
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** Register the scene object with the scene and activate all of its components. */

BansheeCore/Include/BsShader.h

@@ -430,6 +430,7 @@ namespace BansheeEngine
 		/**	Returns a shader object but doesn't initialize it. */
 		static ShaderPtr createEmpty();
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsShaderInclude.h

@@ -21,6 +21,7 @@ namespace BansheeEngine
 		/**	Creates a new include file resource with the specified include string. */
 		static HShaderInclude create(const String& includeString);
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeCore/Include/BsStringTable.h

@@ -290,6 +290,8 @@ namespace BansheeEngine
 		/** Creates a new empty string table resource. */
 		static HStringTable create();
 
+		static const Language DEFAULT_LANGUAGE;
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**
@@ -300,8 +302,6 @@ namespace BansheeEngine
 		static SPtr<StringTable> _createPtr();
 
 		/** @endcond */
-
-		static const Language DEFAULT_LANGUAGE;
 	private:
 		friend class HString;
 		friend class StringTableManager;

BansheeEngine/Include/BsCGUIWidget.h

@@ -52,12 +52,17 @@ namespace BansheeEngine
 		/** @copydoc GUIWidget::getCamera */
 		CameraPtr getCamera() const;
 
-		/** @copydoc GUIWidget::getSkin */
+		/** @copydoc GUIWidget::getElements */
 		const Vector<GUIElement*>& getElements() const;
 
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
 		/** Returns the internal GUIWidget that is wrapped by this component. */
 		GUIWidget* _getInternal() const { return mInternal.get(); };
 
+		/** @endcond */
+
 	protected:
 		friend class SceneObject;
 		friend class GUIElementBase;

BansheeEngine/Include/BsGUIButton.h

@@ -61,6 +61,7 @@ namespace BansheeEngine
 		 */
 		static GUIButton* create(const GUIContent& content, const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** @copydoc GUIElement::getElementType */

BansheeEngine/Include/BsGUIButtonBase.h

@@ -22,6 +22,19 @@ namespace BansheeEngine
 		/**	Change content displayed by the button. */
 		void setContent(const GUIContent& content);
 
+		/**	Triggered when button is clicked. */
+		Event<void()> onClick;
+
+		/**	Triggered when pointer hovers over the button. */
+		Event<void()> onHover;
+
+		/**	Triggered when pointer that was previously hovering leaves the button. */
+		Event<void()> onOut;
+
+		/**	Triggered when button is clicked twice in rapid succession. */
+		Event<void()> onDoubleClick;
+
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**
@@ -46,18 +59,6 @@ namespace BansheeEngine
 		virtual UINT32 _getRenderElementDepthRange() const override;
 
 		/** @endcond */
-
-		/**	Triggered when button is clicked. */
-		Event<void()> onClick;
-
-		/**	Triggered when pointer hovers over the button. */
-		Event<void()> onHover;
-
-		/**	Triggered when pointer that was previously hovering leaves the button. */
-		Event<void()> onOut;
-
-		/**	Triggered when button is clicked twice in rapid succession. */
-		Event<void()> onDoubleClick;
 	protected:
 		GUIButtonBase(const String& styleName, const GUIContent& content, const GUIDimensions& dimensions);
 		virtual ~GUIButtonBase();

BansheeEngine/Include/BsGUIElement.h

@@ -70,10 +70,10 @@ namespace BansheeEngine
 		 */	
 		static void destroy(GUIElement* element);
 
-		/************************************************************************/
-		/* 							INTERNAL METHODS                      		*/
-		/************************************************************************/
+		/**	Triggered when the element loses or gains focus. */
+		Event<void(bool)> onFocusChanged;
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**
@@ -242,9 +242,6 @@ namespace BansheeEngine
 
 		/** @endcond */
 
-		/**	Triggered when the element loses or gains focus. */
-		Event<void(bool)> onFocusChanged;
-
 	protected:
 		/**	Called whenever render elements are dirty and need to be rebuilt. */
 		virtual void updateRenderElementsInternal();

BansheeEngine/Include/BsGUIElementBase.h

@@ -127,10 +127,7 @@ namespace BansheeEngine
 		 */
 		virtual Rect2I getVisibleBounds();
 
-		/************************************************************************/
-		/* 							INTERNAL METHODS                      		*/
-		/************************************************************************/
-
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeEngine/Include/BsGUIInputBox.h

@@ -78,6 +78,13 @@ namespace BansheeEngine
 		 */
 		void setFilter(std::function<bool(const WString&)> filter) { mFilter = filter; }
 
+		/**	Triggered whenever input text has changed. */
+		Event<void(const WString&)> onValueChanged;
+
+		/**	Triggered when the user hits the Enter key with the input box in focus. */
+		Event<void()> onConfirm;
+
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** @copydoc GUIElement::getElementType */
@@ -87,12 +94,6 @@ namespace BansheeEngine
 		virtual Vector2I _getOptimalSize() const override;
 
 		/** @endcond */
-
-		/**	Triggered whenever input text has changed. */
-		Event<void(const WString&)> onValueChanged;
-
-		/**	Triggered when the user hits the Enter key with the input box in focus. */
-		Event<void()> onConfirm;
 	protected:
 		GUIInputBox(const String& styleName, const GUIDimensions& dimensions, bool multiline);
 		virtual ~GUIInputBox();

BansheeEngine/Include/BsGUILabel.h

@@ -63,6 +63,7 @@ namespace BansheeEngine
 		/** Changes the active content of the label. */
 		void setContent(const GUIContent& content);
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** @copydoc GUIElement::_getOptimalSize */

BansheeEngine/Include/BsGUILayout.h

@@ -56,6 +56,10 @@ namespace BansheeEngine
 		/**	Returns number of child elements in the layout. */
 		UINT32 getNumChildren() const { return (UINT32)mChildren.size(); }
 
+		/**	Destroy the layout. Removes it from parent and widget, and deletes it. */
+		static void destroy(GUILayout* layout);
+
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/** @copydoc GUIElementBase::_getLayoutSizeRange */
@@ -81,9 +85,6 @@ namespace BansheeEngine
 
 		/** @endcond */
 
-		/**	Destroy the layout. Removes it from parent and widget, and deletes it. */	
-		static void destroy(GUILayout* layout);
-
 	protected:
 		Vector<LayoutSizeRange> mChildSizeRanges;
 		LayoutSizeRange mSizeRange;

BansheeEngine/Include/BsGUILayoutX.h

@@ -7,10 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Represents a horizontal layout that will layout out its child elements
-	 *			left to right.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** Represents a horizontal layout that will layout out its child elements left to right. */
 	class BS_EXPORT GUILayoutX : public GUILayout
 	{
 	public:
@@ -18,38 +19,35 @@ namespace BansheeEngine
 		GUILayoutX() {};
 		~GUILayoutX() {};
 
+		/**	Creates a new horizontal layout. */
+		static GUILayoutX* create();
+
 		/**
-		 * @brief	Calculate optimal sizes of all child layout elements.
+		 * Creates a new horizontal layout.
+		 *
+		 * @param[in]	options		Options that allow you to control how is the element positioned and sized.
 		 */
+		static GUILayoutX* create(const GUIOptions& options);
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/**	Calculate optimal sizes of all child layout elements. */
 		void _updateOptimalLayoutSizes() override;
 
-		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
-		 */
+		/** @copydoc GUIElementBase::_calculateLayoutSizeRange */
 		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc	GUILayout::_getElementAreas
-		 */
+		/** @copydoc GUILayout::_getElementAreas */
 		void _getElementAreas(const Rect2I& layoutArea, Rect2I* elementAreas, UINT32 numElements,
 			const Vector<LayoutSizeRange>& sizeRanges, const LayoutSizeRange& mySizeRange) const override;
 
-		/**
-		 * @brief	Creates a new horizontal layout.
-		 */
-		static GUILayoutX* create();
-
-		/**
-		 * @brief	Creates a new horizontal layout.
-		 *
-		 * @param	options		Options that allow you to control how is the element positioned and sized.
-		 */
-		static GUILayoutX* create(const GUIOptions& options);
+		/** @endcond */
 
 	protected:
-		/**
-		 * @copydoc	GUIElementBase::_updateLayoutInternal
-		 */
+		/** @copydoc GUIElementBase::_updateLayoutInternal */
 		void _updateLayoutInternal(const GUILayoutData& data) override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUILayoutY.h

@@ -7,10 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Represents a vertical layout that will layout out its child elements
-	 *			top to bottom.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Represents a vertical layout that will layout out its child elements top to bottom. */
 	class BS_EXPORT GUILayoutY : public GUILayout
 	{
 	public:
@@ -18,38 +19,35 @@ namespace BansheeEngine
 		GUILayoutY() {};
 		~GUILayoutY() {};
 
+		/**	Creates a new vertical layout. */
+		static GUILayoutY* create();
+
 		/**
-		 * @brief	Calculate optimal sizes of all child layout elements.
+		 * Creates a new vertical layout.
+		 *
+		 * @param[in]	options		Options that allow you to control how is the element positioned and sized.
 		 */
+		static GUILayoutY* create(const GUIOptions& options);
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/**	Calculate optimal sizes of all child layout elements. */
 		void _updateOptimalLayoutSizes() override;
 
-		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
-		 */
+		/** @copydoc GUIElementBase::_calculateLayoutSizeRange */
 		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc	GUILayout::_getElementAreas
-		 */
+		/** @copydoc GUILayout::_getElementAreas */
 		void _getElementAreas(const Rect2I& layoutArea, Rect2I* elementAreas, UINT32 numElements,
 			const Vector<LayoutSizeRange>& sizeRanges, const LayoutSizeRange& mySizeRange) const override;
 
-		/**
-		 * @brief	Creates a new vertical layout.
-		 */
-		static GUILayoutY* create();
-
-		/**
-		 * @brief	Creates a new vertical layout.
-		 *
-		 * @param	options		Options that allow you to control how is the element positioned and sized.
-		 */
-		static GUILayoutY* create(const GUIOptions& options);
+		/** @endcond */
 
 	protected:
-		/**
-		 * @copydoc	GUIElementBase::_updateLayoutInternal
-		 */
+		/** @copydoc GUIElementBase::_updateLayoutInternal */
 		void _updateLayoutInternal(const GUILayoutData& data) override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIListBox.h

@@ -10,98 +10,87 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	List box GUI element which when active opens a drop down
-	 *			selection with provided elements.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** List box GUI element which when active opens a drop down selection with provided elements. */
 	class BS_EXPORT GUIListBox : public GUIButtonBase
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles. */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new listbox with the provided elements.
+		 * Creates a new listbox with the provided elements.
 		 *
-		 * @param	elements		Elements to display in the list box.
-		 * @param	multiselect		Determines should the listbox allow multiple elements to be selected or just one.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	elements		Elements to display in the list box.
+		 * @param[in]	multiselect		Determines should the listbox allow multiple elements to be selected or just one.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIListBox* create(const Vector<HString>& elements, bool multiselect = false, 
 			const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new listbox with the provided elements.
+		 * Creates a new listbox with the provided elements.
 		 *
-		 * @param	elements		Elements to display in the list box.
-		 * @param	multiselect		Determines should the listbox allow multiple elements to be selected or just one.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	elements		Elements to display in the list box.
+		 * @param[in]	multiselect		Determines should the listbox allow multiple elements to be selected or just one.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIListBox* create(const Vector<HString>& elements, bool multiselect, 
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new single-select listbox with the provided elements.
+		 * Creates a new single-select listbox with the provided elements.
 		 *
-		 * @param	elements		Elements to display in the list box.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	elements		Elements to display in the list box.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIListBox* create(const Vector<HString>& elements, const GUIOptions& options, 
 			const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @brief	Checks whether the listbox supports multiple selected elements at once.
-		 */
+		/**	Checks whether the listbox supports multiple selected elements at once. */
 		bool isMultiselect() const { return mIsMultiselect; }
 
-		/**
-		 * @brief	Changes the list box elements.
-		 */
+		/**	Changes the list box elements. */
 		void setElements(const Vector<HString>& elements);
 
-		/**
-		 * @brief	Makes the element with the specified index selected.
-		 */
+		/**	Makes the element with the specified index selected. */
 		void selectElement(UINT32 idx);
 
-		/**
-		 * @brief	Deselect element the element with the specified index. Only relevant for multi-select list boxes.
-		 */
+		/**	Deselect element the element with the specified index. Only relevant for multi-select list boxes. */
 		void deselectElement(UINT32 idx);
 
-		/**
-		 * @brief	Returns states of all element in the list box (enabled or disabled).
-		 */
+		/**	Returns states of all element in the list box (enabled or disabled). */
 		const Vector<bool>& getElementStates() const { return mElementStates; }
 
 		/**
-		 * @brief	Sets states for all list box elements. Only valid for multi-select list boxes. Number of states
-		 * 			must match number of list box elements.
+		 * Sets states for all list box elements. Only valid for multi-select list boxes. Number of states must match number
+		 * of list box elements.
 		 */
 		void setElementStates(const Vector<bool>& states);
 
 		/**
-		 * @copydoc	GUIButtonBase::getElementType
+		 * Triggered whenever user selects or deselects an element in the list box. Returned index maps to the element in
+		 * the elements array that the list box was initialized with.
 		 */
+		Event<void(UINT32, bool)> onSelectionToggled;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIButtonBase::getElementType */
 		virtual ElementType _getElementType() const override { return ElementType::ListBox; }
 
-		/**
-		 * @brief	Triggered whenever user selects or deselects an element in the list box. Returned index
-		 *			maps to the element in the elements array that the list box was initialized with.
-		 */
-		Event<void(UINT32, bool)> onSelectionToggled;
+		/** @endcond */
 	protected:
 		~GUIListBox();
 
@@ -109,35 +98,22 @@ namespace BansheeEngine
 		GUIListBox(const String& styleName, const Vector<HString>& elements, bool isMultiselect, 
 			const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIButtonBase::mouseEvent
-		 */
+		/** @copydoc GUIButtonBase::mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
-		/**
-		 * @brief	Triggered when user clicks on an element.
-		 */
+		/**	Triggered when user clicks on an element. */
 		void elementSelected(UINT32 idx);
 
-		/**
-		 * @brief	Opens the list box drop down menu.
-		 */
+		/**	Opens the list box drop down menu. */
 		void openListBox();
 
-		/**
-		 * @brief	Closes the list box drop down menu.
-		 */
+		/**	Closes the list box drop down menu. */
 		void closeListBox();
 
-		/**
-		 * @brief	Called when the list box drop down menu is closed
-		 *			by external influence.
-		 */
+		/** Called when the list box drop down menu is closed by external influence. */
 		void onListBoxClosed();
 
-		/**
-		 * @brief	Updates visible contents depending on selected element(s).
-		 */
+		/**	Updates visible contents depending on selected element(s). */
 		void updateContents();
 
 	private:
@@ -147,4 +123,6 @@ namespace BansheeEngine
 
 		bool mIsMultiselect;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIManager.h

@@ -16,28 +16,32 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	class GUIManagerCore;
 
 	/**
-	 * @brief	Manages the rendering and input of all GUI widgets in the scene. 
-	 * 			
-	 * @note	If adding or modifying GUIManager functionality ensure that GUIManager data never gets modified
-	 * 			outside of update() method or Input callbacks. If you need such functionality add temporary variables
-	 * 			that store you changes and then execute them delayed in update().  
+	 * Manages the rendering and input of all GUI widgets in the scene. 
 	 * 			
-	 *			This ensures that GUIElements don't recursively modify GUIManager while GUIManager is still using that data.
-	 *			
-	 *			e.g. setFocus usually gets called from within GUIElements, however we don't want elements in focus be modified immediately 
-	 *			since that setFocus call could have originated in sendCommandEvent and elements in focus array would be modified while
-	 *			still being iterated upon.
-	 *
-	 *			Internal class. Unless modifying internal engine systems you should have no need to access this class.
+	 * @note	
+	 * If adding or modifying GUIManager functionality ensure that GUIManager data never gets modified outside of update()
+	 * method or Input callbacks. If you need such functionality add temporary variables that store you changes and then
+	 * execute them delayed in update().
+	 * @par
+	 * This ensures that GUIElements don't recursively modify GUIManager while GUIManager is still using that data.
+	 * @par
+	 * e.g. setFocus() usually gets called from within GUIElements, however we don't want elements in focus be modified 
+	 * immediately since that setFocus() call could have originated in sendCommandEvent and elements in focus array would
+	 * be modified while still being iterated upon.
+	 * @note
+	 * Internal class. Unless modifying internal engine systems you should have no need to access this class.
 	 */
 	class BS_EXPORT GUIManager : public Module<GUIManager>
 	{
-		/**
-		 * @brief	Valid states of a drag and drop operation
-		 */
+		/**	Valid states of a drag and drop operation. */
 		enum class DragState
 		{
 			NoDrag,
@@ -45,9 +49,7 @@ namespace BansheeEngine
 			Dragging
 		};
 
-		/**
-		 * @brief	GUI render data for a single viewport.
-		 */
+		/**	GUI render data for a single viewport. */
 		struct GUIRenderData
 		{
 			GUIRenderData()
@@ -61,9 +63,7 @@ namespace BansheeEngine
 			bool isDirty;
 		};
 
-		/**
-		 * @brief	Render data for a single GUI group used for notifying the core GUI renderer.
-		 */
+		/**	Render data for a single GUI group used for notifying the core GUI renderer. */
 		struct GUICoreRenderData
 		{
 			SPtr<TransientMeshCore> mesh;
@@ -73,9 +73,7 @@ namespace BansheeEngine
 			Matrix4 worldTransform;
 		};
 
-		/**
-		 * @brief	Container for a GUI widget.
-		 */
+		/**	Container for a GUI widget. */
 		struct WidgetInfo
 		{
 			WidgetInfo(GUIWidget* _widget)
@@ -85,9 +83,7 @@ namespace BansheeEngine
 			GUIWidget* widget;
 		};
 
-		/**
-		 * @brief	Container for data about a single GUI element and its widget.
-		 */
+		/**	Container for data about a single GUI element and its widget. */
 		struct ElementInfo
 		{
 			ElementInfo(GUIElement* element, GUIWidget* widget)
@@ -98,9 +94,7 @@ namespace BansheeEngine
 			GUIWidget* widget;
 		};
 
-		/**
-		 * @brief	Container for data about a single GUI element and its widget currently under the pointer.
-		 */
+		/**	Container for data about a single GUI element and its widget currently under the pointer. */
 		struct ElementInfoUnderPointer
 		{
 			ElementInfoUnderPointer(GUIElement* element, GUIWidget* widget)
@@ -115,9 +109,7 @@ namespace BansheeEngine
 			bool isHovering;
 		};
 
-		/**
-		 * @brief	Container for GUI element in focus.
-		 */
+		/**	Container for GUI element in focus. */
 		struct ElementFocusInfo
 		{
 			GUIElement* element;
@@ -128,252 +120,193 @@ namespace BansheeEngine
 		GUIManager();
 		~GUIManager();
 
-		/**
-		 * @brief	Registers a newly created widget with the GUI manager.
-		 *			This should be called by every GUI widget on creation.
-		 */
+		/** Registers a newly created widget with the GUI manager. This should be called by every GUI widget on creation. */
 		void registerWidget(GUIWidget* widget);
 
 		/**
-		 * @brief	Unregisters a GUI widget from the GUI manager.
-		 *			This should be called by every GUI widget before getting deleted.
+		 * Unregisters a GUI widget from the GUI manager. This should be called by every GUI widget before getting deleted.
 		 */
 		void unregisterWidget(GUIWidget* widget);
 
-		/**
-		 * @brief	Called once per frame.
-		 */
+		/**	Called once per frame. */
 		void update();
 
-		/**
-		 * @brief	Queues the GUI element for destruction. Element will be destroyed during the next
-		 *			call to update().
-		 */
+		/** Queues the GUI element for destruction. Element will be destroyed during the next call to update(). */
 		void queueForDestroy(GUIElement* element);
 
-		/**
-		 * @brief	Change the GUI element focus state.
-		 */
+		/**	Change the GUI element focus state. */
 		void setFocus(GUIElement* element, bool focus);
 
-		/**
-		 * @brief	Changes the color of the input caret used in input boxes and similar controls.
-		 */
+		/**	Changes the color of the input caret used in input boxes and similar controls. */
 		void setCaretColor(const Color& color) { mCaretColor = color; updateCaretTexture(); }
 
-		/**
-		 * @brief	Changes the text selection highlight color used in input boxes and similar controls.
-		 */
+		/**	Changes the text selection highlight color used in input boxes and similar controls. */
 		void setTextSelectionColor(const Color& color) { mTextSelectionColor = color; updateTextSelectionTexture(); }
 
-		/**
-		 * @brief	Returns the default caret texture used for rendering the input caret sprite.
-		 */
+		/**	Returns the default caret texture used for rendering the input caret sprite. */
 		const HSpriteTexture& getCaretTexture() const { return mCaretTexture; }
 
-		/**
-		 * @brief	Returns the default selection highlight texture used for rendering the selection highlight sprites.
-		 */
+		/**	Returns the default selection highlight texture used for rendering the selection highlight sprites. */
 		const HSpriteTexture& getTextSelectionTexture() const { return mTextSelectionTexture; }
 
-		/**
-		 * @brief	Checks is the input caret visible this frame.
-		 */
+		/**	Checks is the input caret visible this frame. */
 		bool getCaretBlinkState() const { return mIsCaretOn; }
 
 		/**
-		 * @brief	Returns input caret helper tool that allows you to easily position and show
-		 *			an input caret in your GUI controls.
+		 * Returns input caret helper tool that allows you to easily position and show an input caret in your GUI controls.
 		 */
 		GUIInputCaret* getInputCaretTool() const { return mInputCaret; }
 
 		/**
-		 * @brief	Returns input selection helper tool that allows you to easily position and show
-		 *			an input selection highlight in your GUI controls.
+		 * Returns input selection helper tool that allows you to easily position and show an input selection highlight in
+		 * your GUI controls.
 		 */
 		GUIInputSelection* getInputSelectionTool() const { return mInputSelection; }
 
 		/**
-		 * @brief	Allows you to bridge GUI input from a GUI element into another render target.
+		 * Allows you to bridge GUI input from a GUI element into another render target.
 		 *
-		 * @param	renderTex 	The render target to which to bridge the input.
-		 * @param	element		The element from which to bridge input. Input will be transformed according to this
-		 * 						elements position and size. Provide nullptr if you want to remove a bridge for the specified widget.
+		 * @param[in]	renderTex 	The render target to which to bridge the input.
+		 * @param[in]	element		The element from which to bridge input. Input will be transformed according to this 
+		 *							elements position and size. Provide nullptr if you want to remove a bridge for the
+		 *							specified widget.
 		 * 					
-		 * @note	This is useful if you use render textures, where your GUI is rendered off-
-		 * 			screen. In such case you need to display the render texture within another GUIElement
-		 * 			in a GUIWidget, but have no way of sending input to the render texture (normally
-		 * 			input is only sent to render windows). This allows you to change that - any GUIWidget
-		 * 			using the bridged render texture as a render target will then receive input when mouse
-		 * 			is over the specified element.
-		 * 			
-		 *			Bridged element needs to remove itself as the bridge when it is destroyed.
+		 * @note	
+		 * This is useful if you use render textures, where your GUI is rendered off-screen. In such case you need to 
+		 * display the render texture within another GUIElement in a GUIWidget, but have no way of sending input to the
+		 * render texture (normally input is only sent to render windows). This allows you to change that - any GUIWidget
+		 * using the bridged render texture as a render target will then receive input when mouse is over the specified
+		 * element.
+		 * @note			
+		 * Bridged element needs to remove itself as the bridge when it is destroyed.
 		 */
 		void setInputBridge(const RenderTexture* renderTex, const GUIElement* element);
 
-		/**
-		 * @brief	Gets the core thread portion of the GUI manager, responsible for rendering
-		 * 			of GUI elements.
-		 */
+		/** Gets the core thread portion of the GUI manager, responsible for rendering of GUI elements. */
 		GUIManagerCore* getCore() const { return mCore.load(std::memory_order_relaxed); }
 
 	private:
 		friend class GUIManagerCore;
 
-		/**
-		 * @brief	Recreates all dirty GUI meshes and makes them ready for rendering.
-		 */
+		/**	Recreates all dirty GUI meshes and makes them ready for rendering. */
 		void updateMeshes();
 
-		/**
-		 * @brief	Recreates the input caret texture.
-		 */
+		/**	Recreates the input caret texture. */
 		void updateCaretTexture();
 
-		/**
-		 * @brief	Recreates the input text selection highlight texture.
-		 */
+		/**	Recreates the input text selection highlight texture. */
 		void updateTextSelectionTexture();
 
 		/**
-		 * @brief	Destroys the core thread counterpart of the GUI manager.
+		 * Destroys the core thread counterpart of the GUI manager.
 		 *
-		 * @param	core	Previously constructed core thread GUI manager instance.
+		 * @param[in]	core	Previously constructed core thread GUI manager instance.
 		 */
 		void destroyCore(GUIManagerCore* core);
 
 		/**
-		 * @brief	Destroys any elements or widgets queued for destruction.
+		 * Destroys any elements or widgets queued for destruction.
 		 *
-		 * @note	Returns true if more elements have been added for destruction (will happen when destruction
-		 *			of one element queues up destruction of another).
+		 * @note	
+		 * Returns true if more elements have been added for destruction (will happen when destruction of one element
+		 * queues up destruction of another).
 		 */
 		bool processDestroyQueue();
 
 		/**
-		 * @brief	Finds a GUI element under the pointer at the specified screen position. This method will also
-		 *			trigger pointer move/hover/leave events.
+		 * Finds a GUI element under the pointer at the specified screen position. This method will also trigger pointer
+		 * move/hover/leave events.
 		 *
-		 * @param	screenMousePos	Position of the pointer in screen coordinates.
-		 * @param	buttonStates	States of the three mouse buttons (left, right, middle).
-		 * @param	shift			Is shift key held.
-		 * @param	control			Is control key held.
-		 * @param	alt				Is alt key held.
+		 * @param[in]	screenMousePos	Position of the pointer in screen coordinates.
+		 * @param[in]	buttonStates	States of the three mouse buttons (left, right, middle).
+		 * @param[in]	shift			Is shift key held.
+		 * @param[in]	control			Is control key held.
+		 * @param[in]	alt				Is alt key held.
 		 */
 		bool findElementUnderPointer(const Vector2I& screenMousePos, bool buttonStates[3], bool shift, bool control, bool alt);
 
-		/**
-		 * @brief	Called whenever a pointer (e.g. mouse cursor) is moved.
-		 */
+		/**	Called whenever a pointer (e.g. mouse cursor) is moved. */
 		void onPointerMoved(const PointerEvent& event);
 
-		/**
-		 * @brief	Called whenever a pointer button (e.g. mouse button) is released.
-		 */
+		/**	Called whenever a pointer button (e.g. mouse button) is released. */
 		void onPointerReleased(const PointerEvent& event);
 
-		/**
-		 * @brief	Called whenever a pointer button (e.g. mouse button) is pressed.
-		 */
+		/**	Called whenever a pointer button (e.g. mouse button) is pressed. */
 		void onPointerPressed(const PointerEvent& event);
 
-		/**
-		 * @brief	Called whenever a pointer button (e.g. mouse button) is double clicked.
-		 */
+		/**	Called whenever a pointer button (e.g. mouse button) is double clicked. */
 		void onPointerDoubleClick(const PointerEvent& event);
 
-		/**
-		 * @brief	Called whenever a text is input.
-		 */
+		/**	Called whenever a text is input. */
 		void onTextInput(const TextInputEvent& event);
 
-		/**
-		 * @brief	Called whenever an input command is input.
-		 */
+		/**	Called whenever an input command is input. */
 		void onInputCommandEntered(InputCommandType commandType);
 
-		/**
-		 * @brief	Called whenever a virtual button is pressed.
-		 */
+		/**	Called whenever a virtual button is pressed. */
 		void onVirtualButtonDown(const VirtualButton& button, UINT32 deviceIdx);
 
-		/**
-		 * @brief	Called by the drag and drop managed to notify us the drag ended.
-		 */
+		/**	Called by the drag and drop managed to notify us the drag ended. */
 		void onMouseDragEnded(const PointerEvent& event, DragCallbackInfo& dragInfo);
 
-		/**
-		 * @brief	Called when the specified window gains focus.
-		 */
+		/**	Called when the specified window gains focus. */
 		void onWindowFocusGained(RenderWindow& win);
 
-		/**
-		 * @brief	Called when the specified window loses focus.
-		 */
+		/**	Called when the specified window loses focus. */
 		void onWindowFocusLost(RenderWindow& win);
 
-		/**
-		 * @brief	Called when the mouse leaves the specified window.
-		 */
+		/**	Called when the mouse leaves the specified window. */
 		void onMouseLeftWindow(RenderWindow& win);
 
-		/**
-		 * @brief	Converts pointer buttons to mouse buttons.
-		 */
+		/**	Converts pointer buttons to mouse buttons. */
 		GUIMouseButton buttonToGUIButton(PointerEventButton pointerButton) const;
 
-		/**
-		 * @brief	Converts screen coordinates to coordinates relative to the specified widget.
-		 */
+		/**	Converts screen coordinates to coordinates relative to the specified widget. */
 		Vector2I getWidgetRelativePos(const GUIWidget* widget, const Vector2I& screenPos) const;
 
 		/**
-		 * @brief	Converts window coordinates to coordinates relative to the specified bridged widget.
-		 *			Returned coordinates will be relative to the bridge element.
+		 * Converts window coordinates to coordinates relative to the specified bridged widget. Returned coordinates will
+		 * be relative to the bridge element.
 		 *
-		 * @param	If provided widget has no bridge, coordinates are returned as is.
+		 * @param[in]	If provided widget has no bridge, coordinates are returned as is.
 		 */
 		Vector2I windowToBridgedCoords(const GUIWidget& widget, const Vector2I& windowPos) const;
 
-		/**
-		 * @brief	Returns the parent render window of the specified widget.
-		 */
+		/**	Returns the parent render window of the specified widget. */
 		const RenderWindow* getWidgetWindow(const GUIWidget& widget) const;
 
-		/**
-		 * @brief	Hides the tooltip if any is shown.
-		 */
+		/**	Hides the tooltip if any is shown. */
 		void hideTooltip();
 
 		/**
-		 * @brief	Sends a mouse event to the specified GUI element.
+		 * Sends a mouse event to the specified GUI element.
 		 *
-		 * @param	element	Element to send the event to.
-		 * @param	event	Event data.
+		 * @param[in]	element	Element to send the event to.
+		 * @param[in]	event	Event data.
 		 */
 		bool sendMouseEvent(GUIElement* element, const GUIMouseEvent& event);
 
 		/**
-		 * @brief	Sends a text input event to the specified GUI element.
+		 * Sends a text input event to the specified GUI element.
 		 *
-		 * @param	element	Element to send the event to.
-		 * @param	event	Event data.
+		 * @param[in]	element	Element to send the event to.
+		 * @param[in]	event	Event data.
 		 */
 		bool sendTextInputEvent(GUIElement* element, const GUITextInputEvent& event);
 
 		/**
-		 * @brief	Sends a command event to the specified GUI element.
+		 * Sends a command event to the specified GUI element.
 		 *
-		 * @param	element	Element to send the event to.
-		 * @param	event	Event data.
+		 * @param[in]	element	Element to send the event to.
+		 * @param[in]	event	Event data.
 		 */
 		bool sendCommandEvent(GUIElement* element, const GUICommandEvent& event);
 
 		/**
-		 * @brief	Sends a virtual button event to the specified GUI element.
+		 * Sends a virtual button event to the specified GUI element.
 		 *
-		 * @param	element	Element to send the event to.
-		 * @param	event	Event data.
+		 * @param[in]	element	Element to send the event to.
+		 * @param[in]	event	Event data.
 		 */
 		bool sendVirtualButtonEvent(GUIElement* element, const GUIVirtualButtonEvent& event);
 
@@ -456,9 +389,7 @@ namespace BansheeEngine
 		HEvent mMouseLeftWindowConn;
 	};
 
-	/**
-	 * @brief	Handles GUI rendering on the core thread.
-	 */
+	/**	Handles GUI rendering on the core thread. */
 	class BS_EXPORT GUIManagerCore
 	{
 		friend class GUIManager;
@@ -494,16 +425,13 @@ namespace BansheeEngine
 
 	private:
 		/**
-		 * @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	data	GUI mesh/material per viewport.
+		 * @param[in]	data	GUI mesh/material per viewport.
 		 */
 		void updateData(const UnorderedMap<SPtr<CameraCore>, Vector<GUIManager::GUICoreRenderData>>& perCameraData);
 
-		/**
-		 * @brief	Triggered by the Renderer when the GUI should be rendered.
-		 */
+		/**	Triggered by the Renderer when the GUI should be rendered. */
 		void render(const SPtr<CameraCore>& camera);
 
 		UnorderedMap<SPtr<CameraCore>, Vector<GUIManager::GUICoreRenderData>> mPerCameraData;
@@ -516,8 +444,9 @@ namespace BansheeEngine
 		SPtr<SamplerStateCore> mSamplerState;
 	};
 
-	/**
-	 * @copydoc	GUIManager
-	 */
+	/** Provides easier access to GUIManager. */
 	BS_EXPORT GUIManager& gGUIManager();
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIMenu.h

@@ -8,106 +8,83 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	class GUIMenuItem;
 
-	/**
-	 * @brief	Used for comparing GUI menu items in order to determine the order
-	 *			in which they are presented.
-	 */
+	/** Used for comparing GUI menu items in order to determine the order in which they are presented. */
 	struct GUIMenuItemComparer
 	{
 		bool operator() (const GUIMenuItem* const& a, const GUIMenuItem* const& b);
 	};
 
-	/**
-	 * Holds information about a single element in a GUI menu.
-	 */
+	/** Holds information about a single element in a GUI menu. */
 	class BS_EXPORT GUIMenuItem
 	{
 	public:
 		/**
-		 * @brief	Constructs a new non-separator menu item.
+		 * Constructs a new non-separator menu item.
 		 *
-		 * @param	parent		Parent item, if any.
-		 * @param	name		Name of the item to be displayed.
-		 * @param	callback	Callback to be triggered when menu items is selected.
-		 * @param	priority	Priority that determines the order of this element compared to its siblings.
-		 * @param	seqIdx		Sequential index of the menu item that specifies in what order was it added to the menu
-		 * 						compared to other items.
-		 * @param	key			Keyboard shortcut that can be used for triggering the menu item.
+		 * @param[in]	parent		Parent item, if any.
+		 * @param[in]	name		Name of the item to be displayed.
+		 * @param[in]	callback	Callback to be triggered when menu items is selected.
+		 * @param[in]	priority	Priority that determines the order of this element compared to its siblings.
+		 * @param[in]	seqIdx		Sequential index of the menu item that specifies in what order was it added to the menu
+		 * 							compared to other items.
+		 * @param[in]	key			Keyboard shortcut that can be used for triggering the menu item.
 		 */
 		GUIMenuItem(GUIMenuItem* parent, const WString& name, std::function<void()> callback, 
 			INT32 priority, UINT32 seqIdx, const ShortcutKey& key);
 
 		/**
-		 * @brief	Constructs a new separator menu item.
+		 * Constructs a new separator menu item.
 		 *
-		 * @param	parent		Parent item, if any.
-		 * @param	priority	Priority that determines the order of this element compared to its siblings.
-		 * @param	seqIdx		Sequential index of the menu item that specifies in what order was it added to the menu
-		 * 						compared to other items.
+		 * @param[in]	parent		Parent item, if any.
+		 * @param[in]	priority	Priority that determines the order of this element compared to its siblings.
+		 * @param[in]	seqIdx		Sequential index of the menu item that specifies in what order was it added to the menu
+		 * 							compared to other items.
 		 */
 		GUIMenuItem(GUIMenuItem* parent, INT32 priority, UINT32 seqIdx);
 		~GUIMenuItem();
 
-		/**
-		 * @brief	Registers a new child with the item.
-		 */
+		/**	Registers a new child with the item. */
 		void addChild(GUIMenuItem* child) { mChildren.insert(child); }
 
-		/**
-		 * @brief	Returns number of child menu items.
-		 */
+		/**	Returns number of child menu items. */
 		UINT32 getNumChildren() const { return (UINT32)mChildren.size(); }
 
-		/**
-		 * @brief	Returns the parent menu item, or null if none.
-		 */
-		GUIMenuItem* getParent() { return mParent; }
+		/**	Returns the parent menu item, or null if none. */
+		GUIMenuItem* getParent() const { return mParent; }
 
-		/**
-		 * @brief	Returns name of the menu item. Empty if separator.
-		 */
+		/**	Returns name of the menu item. Empty if separator. */
 		const WString& getName() const { return mName; }
 
-		/**
-		 * @brief	Returns callback that will trigger when menu item is selected. Null for separators.
-		 */
+		/**	Returns callback that will trigger when menu item is selected. Null for separators. */
 		std::function<void()> getCallback() const { return mCallback; }
 
-		/**
-		 * @brief	Returns a keyboard shortcut that may be used for triggering the menu item callback.
-		 */
+		/**	Returns a keyboard shortcut that may be used for triggering the menu item callback. */
 		const ShortcutKey& getShortcut() const { return mShortcut; }
 
-		/**
-		 * @brief	Checks is the menu item a separator or a normal named menu item.
-		 */
+		/**	Checks is the menu item a separator or a normal named menu item. */
 		bool isSeparator() const { return mIsSeparator; }
 
-		/**
-		 * @brief	Attempts to find a child menu item with the specified name.
-		 *			Only direct descendants are searched.
-		 */
+		/** Attempts to find a child menu item with the specified name. Only direct descendants are searched. */
 		const GUIMenuItem* findChild(const WString& name) const;
 
-		/**
-		 * @brief	Removes the first child with the specified name.
-		 */
+		/**	Removes the first child with the specified name. */
 		void removeChild(const WString& name);
 
-		/**
-		 * @brief	Removes the specified child.
-		 */
+		/**	Removes the specified child. */
 		void removeChild(const GUIMenuItem* item);
 
 	private:
 		friend class GUIMenu;
 		friend struct GUIMenuItemComparer;
 
-		/**
-		 * @copydoc	GUIMenuitem::findChild(const WString& name) const
-		 */
+		/** @copydoc GUIMenuitem::findChild(const WString& name) const */
 		GUIMenuItem* findChild(const WString& name);
 
 		GUIMenuItem* mParent;
@@ -125,12 +102,12 @@ namespace BansheeEngine
 	 * Menu consists out of a number of top level elements, each of which opens
 	 * a drop down menu which may internally hold a deeper hierarchy of menus.
 	 *
-	 * @note	When specifying menu items you must provide a path. Path must be formated in a certain way.
-	 *			All path elements must be separated by /, e.g. "View/Toolbars/Find". "View" would be the top
-	 *			level path element, "Toolbars" a child in its menu that opens up its own submenu, and "Find"
-	 *			a child in the "Toolbars" sub-menu with an optional callback.
-	 *
-	 *			This is an abstract class and you should provide specialized implementations for specific menu types.
+	 * @note	
+	 * When specifying menu items you must provide a path. Path must be formated in a certain way. All path elements must
+	 * be separated by /, e.g. "View/Toolbars/Find". "View" would be the top level path element, "Toolbars" a child in its
+	 * menu that opens up its own submenu, and "Find" a child in the "Toolbars" sub-menu with an optional callback.
+	 * @note
+	 * This is an abstract class and you should provide specialized implementations for specific menu types.
 	 */
 	class BS_EXPORT GUIMenu
 	{
@@ -139,70 +116,64 @@ namespace BansheeEngine
 		virtual ~GUIMenu();
 
 		/**
-		 * @brief	Adds a new menu item with the specified callback. 
+		 * Adds a new menu item with the specified callback. 
 		 *			
-		 * @param	path		Path that determines where to add the element. See class information on how to specify paths.
-		 *						All sub-elements of a path will be added automatically.
-		 * @param	callback	Callback that triggers when the path element is selected.
-		 * @param	priority	Priority determines the position of the menu item relative to its siblings.
-		 *						Higher priority means it will be placed earlier in the menu.
-		 * @param	key			Keyboard shortcut that can be used for triggering the menu item.
-		 *
-		 * @returns	A menu item object that you may use for removing the menu item later. Its lifetime is managed internally.
+		 * @param[in]	path		Path that determines where to add the element. See class information on how to specify
+		 *							paths. All sub-elements of a path will be added automatically.
+		 * @param[in]	callback	Callback that triggers when the path element is selected.
+		 * @param[in]	priority	Priority determines the position of the menu item relative to its siblings. Higher 
+		 *							priority means it will be placed earlier in the menu.
+		 * @param[in]	key			Keyboard shortcut that can be used for triggering the menu item.
+		 * @return					A menu item object that you may use for removing the menu item later. Its lifetime is
+		 *							managed internally.
 		 */
 		GUIMenuItem* addMenuItem(const WString& path, std::function<void()> callback, INT32 priority, const ShortcutKey& key = ShortcutKey::NONE);
 
 		/**
-		 * @brief	Adds a new separator menu item with the specified callback.
+		 * Adds a new separator menu item with the specified callback.
 		 *			
-		 * @param	path		Path that determines where to add the element. See class information on how to specify paths.
-		 *						All sub-elements of a path will be added automatically.
-		 * @param	priority	Priority determines the position of the menu item relative to its siblings.
-		 *						Higher priority means it will be placed earlier in the menu.
-		 *
-		 * @returns	A menu item object that you may use for removing the menu item later. Its lifetime is managed internally.
+		 * @param[in]	path		Path that determines where to add the element. See class information on how to specify 
+		 *							paths. All sub-elements of a path will be added automatically.
+		 * @param[in]	priority	Priority determines the position of the menu item relative to its siblings. Higher
+		 *							priority means it will be placed earlier in the menu.
+		 * @return					A menu item object that you may use for removing the menu item later. Its lifetime is
+		 *							managed internally.
 		 */
 		GUIMenuItem* addSeparator(const WString& path, INT32 priority);
 
-		/**
-		 * @brief	Returns a menu item at the specified path, or null if one is not found.
-		 */
+		/**	Returns a menu item at the specified path, or null if one is not found. */
 		GUIMenuItem* getMenuItem(const WString& path);
 
-		/**
-		 * @brief	Removes the specified menu item from the path. If the menu item has any sub-menus they will also be removed.
-		 */
+		/**	Removes the specified menu item from the path. If the menu item has any sub-menus they will also be removed. */
 		void removeMenuItem(const GUIMenuItem* item);
 
 		/**
-		 * @brief	Normally menu items use values from their paths as their names. However path labels don't provide a way of
-		 * 			localizing the menu item. This method allows you to set specific names (different from path labels)
-		 * 			to each menu item. All the values are localized so they will also be updated according to the string table.
+		 * Normally menu items use values from their paths as their names. However path labels don't provide a way of
+		 * localizing the menu item. This method allows you to set specific names (different from path labels) to each menu
+		 * item. All the values are localized so they will also be updated according to the string table.
 		 *
-		 * @param	menuItemLabel	The menu item label. (e.g. if you have a menu like "View/Toolbars/Find, this parameter would be either
-		 * 							"View", "Toolbars" or "Find" depending which entry you want to localize)
-		 * @param	localizedName	Localized string with the name.
+		 * @param[in]	menuItemLabel	The menu item label. (e.g. if you have a menu like "View/Toolbars/Find, this 
+		 *								parameter would be either "View", "Toolbars" or "Find" depending which entry you 
+		 *								want to localize)
+		 * @param[in]	localizedName	Localized string with the name.
 		 */
 		void setLocalizedName(const WString& menuItemLabel, const HString& localizedName);
 
-		/**
-		 * @brief	Returns data used for initializing a drop down list, for all elements.
-		 */
+		/**	Returns data used for initializing a drop down list, for all elements. */
 		GUIDropDownData getDropDownData() const;
 	protected:
-		/**
-		 * @brief	Adds a menu item at the specified path, as a normal button or as a separator.
-		 */
+		/**	Adds a menu item at the specified path, as a normal button or as a separator. */
 		GUIMenuItem* addMenuItemInternal(const WString& path, std::function<void()> callback, bool isSeparator, 
 			INT32 priority, const ShortcutKey& key);
 
-		/**
-		 * @brief	Return drop down data for the specified menu.
-		 */
+		/**	Return drop down data for the specified menu. */
 		GUIDropDownData getDropDownDataInternal(const GUIMenuItem& menu) const;
 
 		GUIMenuItem mRootElement;
 		UnorderedMap<WString, HString> mLocalizedEntryNames;
 		UINT32 mNextIdx;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIMouseEvent.h

@@ -7,9 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Types of GUI mouse events.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Types of GUI mouse events. */
 	enum class GUIMouseEventType
 	{
 		MouseOver,
@@ -27,19 +29,15 @@ namespace BansheeEngine
 		MouseDragAndDropLeft
 	};
 
-	/**
-	 * @brief	Types of GUI mouse buttons.
-	 */
+	/**	Types of GUI mouse buttons. */
 	enum class GUIMouseButton
 	{
 		Left, Right, Middle, Count
 	};
 
 	/**
-	 * @brief	Contains data about a GUI mouse input event.
-	 *			This class may store data for many types of events, and some data
-	 *			might not be initialized for some event types. Caller must check
-	 *			event type before relying on the data inside.
+	 * Contains data about a GUI mouse input event. This class may store data for many types of events, and some data might
+	 * not be initialized for some event types. Caller must check event type before relying on the data inside.
 	 */
 	class BS_EXPORT GUIMouseEvent
 	{
@@ -48,130 +46,83 @@ namespace BansheeEngine
 		GUIMouseEvent(bool buttonStates[(int)GUIMouseButton::Count], bool shift, bool ctrl, bool alt);
 
 		/**
-		 * @brief	The position of the mouse when the event happened. This is relative to the
-		 *			parent widget of the element this event is being sent to.
+		 * The position of the mouse when the event happened. This is relative to the parent widget of the element this
+		 * event is being sent to.
 		 */
 		const Vector2I& getPosition() const { return mPosition; }
 
-		/**
-		 * @brief	Returns the internal type of the event.
-		 */
+		/**	Returns the internal type of the event. */
 		GUIMouseEventType getType() const { return mType; }
 
-		/**
-		 * @brief	Returns the mouse button involved in the event, if any.
-		 */
+		/**	Returns the mouse button involved in the event, if any. */
 		GUIMouseButton getButton() const { return mButton; }
 
-		/**
-		 * @brief	Returns drag amount in pixels, if event is drag related.
-		 */
+		/**	Returns drag amount in pixels, if event is drag related. */
 		Vector2I getDragAmount() const { return mDragAmount; }
 
-		/**
-		 * @brief	Returns the position where the drag was started from, if event is drag related.
-		 */
+		/**	Returns the position where the drag was started from, if event is drag related. */
 		Vector2I getDragStartPosition() const { return mDragStartPosition; }
 
-		/**
-		 * @brief	Returns amount of mouse wheel scroll, if event is scroll wheel related.
-		 */
+		/**	Returns amount of mouse wheel scroll, if event is scroll wheel related. */
 		float getWheelScrollAmount() const { return mWheelScrollAmount; }
 
-		/**
-		 * @brief	Checks is the specified mouse button pressed.
-		 */
+		/**	Checks is the specified mouse button pressed. */
 		bool isButtonDown(GUIMouseButton button) const { return mButtonStates[(int)button]; }
 
-		/**
-		 * @brief	Gets the current drag and drop operation type id. Only valid if event is drag and drop related.
-		 */
+		/**	Gets the current drag and drop operation type id. Only valid if event is drag and drop related. */
 		UINT32 getDragAndDropTypeId() const { return mDragTypeId; }
 
-		/**
-		 * @brief	Returns internal data being dragged by a drag and drop event. . Only valid if event is drag and drop related.
-		 */
+		/** Returns internal data being dragged by a drag and drop event. . Only valid if event is drag and drop related. */
 		void* getDragAndDropData() const { return mDragData; }
 
-		/**
-		 * @brief	Checks is the shift button being held.
-		 */
+		/**	Checks is the shift button being held. */
 		bool isShiftDown() const { return mShift; }
 
-		/**
-		 * @brief	Checks is the control button being held.
-		 */
+		/**	Checks is the control button being held. */
 		bool isCtrlDown() const { return mCtrl; }
 
-		/**
-		 * @brief	Checks is the alt button being held.
-		 */
+		/**	Checks is the alt button being held. */
 		bool isAltDown() const { return mAlt; }
 	private:
 		friend class GUIManager;
 
-		/**
-		 * @brief	Initializes the event with MouseOver event data.
-		 */
+		/**	Initializes the event with MouseOver event data. */
 		void setMouseOverData(const Vector2I& position);
 
-		/**
-		 * @brief	Initializes the event with MouseOut event data.
-		 */
+		/**	Initializes the event with MouseOut event data. */
 		void setMouseOutData(const Vector2I& position);
 
-		/**
-		 * @brief	Initializes the event with MouseMove event data.
-		 */
+		/**	Initializes the event with MouseMove event data. */
 		void setMouseMoveData(const Vector2I& position);
 
-		/**
-		 * @brief	Initializes the event with MouseWheelScroll event data.
-		 */
+		/**	Initializes the event with MouseWheelScroll event data. */
 		void setMouseWheelScrollData(float scrollAmount);
 
-		/**
-		 * @brief	Initializes the event with MouseUp event data.
-		 */
+		/**	Initializes the event with MouseUp event data. */
 		void setMouseUpData(const Vector2I& position, GUIMouseButton button);
 
-		/**
-		 * @brief	Initializes the event with MouseDown event data.
-		 */
+		/**	Initializes the event with MouseDown event data. */
 		void setMouseDownData(const Vector2I& position, GUIMouseButton button);
 
-		/**
-		 * @brief	Initializes the event with MouseDoubleClick event data.
-		 */
+		/**	Initializes the event with MouseDoubleClick event data. */
 		void setMouseDoubleClickData(const Vector2I& position, GUIMouseButton button);
 
-		/**
-		 * @brief	Initializes the event with MouseDrag event data.
-		 */
+		/**	Initializes the event with MouseDrag event data. */
 		void setMouseDragData(const Vector2I& position, const Vector2I& dragStartPosition);
 
-		/**
-		 * @brief	Initializes the event with MouseDragStart event data.
-		 */
+		/**	Initializes the event with MouseDragStart event data. */
 		void setMouseDragStartData(const Vector2I& position, const Vector2I& dragStartPosition);
-		/**
-		 * @brief	Initializes the event with MouseDragEnd event data.
-		 */
+
+		/**	Initializes the event with MouseDragEnd event data. */
 		void setMouseDragEndData(const Vector2I& position);
 
-		/**
-		 * @brief	Initializes the event with DragAndDropDropped event data.
-		 */
+		/**	Initializes the event with DragAndDropDropped event data. */
 		void setDragAndDropDroppedData(const Vector2I& position, UINT32 dragTypeId, void* dragData);
 
-		/**
-		 * @brief	Initializes the event with DragAndDropDragged event data.
-		 */
+		/**	Initializes the event with DragAndDropDragged event data. */
 		void setDragAndDropDraggedData(const Vector2I& position, UINT32 dragTypeId, void* dragData);
 
-		/**
-		 * @brief	Initializes the event with DragAndDropLeft event data.
-		 */
+		/**	Initializes the event with DragAndDropLeft event data. */
 		void setDragAndDropLeftData(const Vector2I& position, UINT32 dragTypeId, void* dragData);
 
 		bool mButtonStates[(int)GUIMouseButton::Count];
@@ -188,4 +139,6 @@ namespace BansheeEngine
 		bool mCtrl;
 		bool mAlt;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIOptions.h

@@ -6,16 +6,17 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Controls GUI element layout options, possibly by overriding
-	 *			the default options specified in GUI element style. These options
-	 *			control GUI element placement and size in a GUI layout.
+	 * Controls GUI element layout options, possibly by overriding the default options specified in GUI element style. 
+	 * These options control GUI element placement and size in a GUI layout.
 	 */
 	class BS_EXPORT GUIOption
 	{
-		/**
-		 * @brief	Type of GUI element options.
-		 */
+		/**	Type of GUI element options. */
 		enum class Type
 		{
 			FixedWidth,
@@ -29,35 +30,32 @@ namespace BansheeEngine
 		GUIOption();
 
 		/**
-		 * @brief	Constructs a GUI option notifying the GUI layout that this element should be positioned
-		 *			at this offset from the parent GUI panel. This option is ignored if element is part of a 
-		 *			layout since it controls its placement.
+		 * Constructs a GUI option notifying the GUI layout that this element should be positioned at this offset from the
+		 * parent GUI panel. This option is ignored if element is part of a layout since it controls its placement.
 		 */
 		static GUIOption position(INT32 x, INT32 y);
 
 		/**
-		 * @brief	Constructs a GUI option notifying the GUI layout that this element has a fixed width.
-		 *			This will override the width property set in element style.
+		 * Constructs a GUI option notifying the GUI layout that this element has a fixed width. This will override the 
+		 * width property set in element style.
 		 */
 		static GUIOption fixedWidth(UINT32 value);
 
 		/**
-		 * @brief	Constructs a GUI option notifying the GUI layout that this element has a flexible width with
-		 *			optional min/max constraints (value of 0 means no constraint). This will override the width property 
-		 *			set in element style.
+		 * Constructs a GUI option notifying the GUI layout that this element has a flexible width with optional min/max
+		 * constraints (value of 0 means no constraint). This will override the width property set in element style.
 		 */
 		static GUIOption flexibleWidth(UINT32 min = 0, UINT32 max = 0);
 
 		/**
-		 * @brief	Constructs a GUI option notifying the GUI layout that this element has a fixed height.
-		 *			This will override the height property set in element style.
+		 * Constructs a GUI option notifying the GUI layout that this element has a fixed height. This will override the
+		 * height property set in element style.
 		 */
 		static GUIOption fixedHeight(UINT32 value);
 
 		/**
-		 * @brief	Constructs a GUI option notifying the GUI layout that this element has a flexible height with
-		 *			optional min/max constraints (value of 0 means no constraint). This will override the height property 
-		 *			set in element style.
+		 * Constructs a GUI option notifying the GUI layout that this element has a flexible height with optional min/max 
+		 * constraints (value of 0 means no constraint). This will override the height property set in element style.
 		 */
 		static GUIOption flexibleHeight(UINT32 min = 0, UINT32 max = 0);
 
@@ -68,9 +66,7 @@ namespace BansheeEngine
 		Type type;
 	};
 
-	/**
-	 * @brief	Container for a list of options used for controlling GUI element properties.
-	 */
+	/**	Container for a list of options used for controlling GUI element properties. */
 	class BS_EXPORT GUIOptions
 	{
 	public:
@@ -113,9 +109,7 @@ namespace BansheeEngine
 			mOptions.push_back(e4);
 		}
 
-		/**
-		 * @brief	Adds a new option to the options list. 
-		 */
+		/**	Adds a new option to the options list.  */
 		void addOption(const GUIOption& option)
 		{
 			mOptions.push_back(option);
@@ -126,4 +120,6 @@ namespace BansheeEngine
 
 		Vector<GUIOption> mOptions;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIPanel.h

@@ -7,10 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Represents a GUI panel that you can use for free placement 
-	 *			of GUI elements within its bounds.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Represents a GUI panel that you can use for free placement of GUI elements within its bounds. */
 	class BS_EXPORT GUIPanel : public GUILayout
 	{
 	public:
@@ -19,117 +20,104 @@ namespace BansheeEngine
 		~GUIPanel() {};
 
 		/**
-		 * @copydoc	GUIElementBase::_getType
+		 * Changes values that control at which depth is GUI panel and its children rendered.
+		 *
+		 * @param[in]	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
+		 *								rendered in front of panels with higher depth. Provided depth is relative to depth
+		 *								of the parent GUI panel (if any).
+		 * @param[in]	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will
+		 *								be clamped to nearest extreme. Value of -1 means infinite range.
+		 * @param[in]	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will
+		 *								be clamped to nearest extreme. Value of -1 means infinite range.
 		 */
-		virtual Type _getType() const override { return GUIElementBase::Type::Panel; }
+		void setDepthRange(INT16 depth = 0, UINT16 depthRangeMin = -1, UINT16 depthRangeMax = -1);
 
 		/**
-		 * @brief	Calculate optimal sizes of all child layout elements.
+		 * Creates a new GUI panel.
+		 *
+		 * @param[in]	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
+		 *								rendered in front of panels with higher depth. Provided depth is relative to depth
+		 *								of the parent GUI panel (if any).
+		 * @param[in]	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will
+		 *								be clamped to nearest extreme. Value of -1 means infinite range.
+		 * @param[in]	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will
+		 *								be clamped to nearest extreme. Value of -1 means infinite range.
 		 */
-		void _updateOptimalLayoutSizes() override;
+		static GUIPanel* create(INT16 depth = 0, UINT16 depthRangeMin = -1, UINT16 depthRangeMax = -1);
 
 		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
+		 * Creates a new GUI panel.
+		 *
+		 * @param[in]	depth		Determines rendering order of the GUI panel. Panels with lower depth will be rendered
+		 *							in front of panels with higher depth. Provided depth is relative to depth of the parent
+		 *							GUI panel (if any).
 		 */
-		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
+		static GUIPanel* create(const GUIOptions& options);
 
 		/**
-		 * @copydoc	GUILayout::_getElementAreas
+		 * Creates a new GUI panel.
+		 *
+		 * @param[in]	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
+		 *								rendered in front of panels with higher depth. Provided depth is relative to depth
+		 *								of the parent GUI panel (if any).
+		 * @param[in]	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be
+		 *								clamped to nearest extreme. Value of -1 means infinite range.
+		 * @param[in]	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has
+		 *								depth outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be
+		 *								clamped to nearest extreme. Value of -1 means infinite range.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
 		 */
+		static GUIPanel* create(INT16 depth, UINT16 depthRangeMin, UINT16 depthRangeMax, const GUIOptions& options);
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElementBase::_getType */
+		virtual Type _getType() const override { return GUIElementBase::Type::Panel; }
+
+		/**	Calculate optimal sizes of all child layout elements. */
+		void _updateOptimalLayoutSizes() override;
+
+		/** @copydoc GUIElementBase::_calculateLayoutSizeRange */
+		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
+
+		/** @copydoc GUILayout::_getElementAreas */
 		void _getElementAreas(const Rect2I& layoutArea, Rect2I* elementAreas, UINT32 numElements,
 			const Vector<LayoutSizeRange>& sizeRanges, const LayoutSizeRange& mySizeRange) const override;
 
-		/**
-		 * @brief	Calculates the size of the provided child within this layout with the provided dimensions.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Calculates the size of the provided child within this layout with the provided dimensions. */
 		Rect2I _getElementArea(const Rect2I& layoutArea, const GUIElementBase* element, const LayoutSizeRange& sizeRange) const;
 
 		/**
-		 * @brief	Calculates an element size range for the provided child of the GUI panel. Will return cached bounds
-		 *			so make sure to update optimal size ranges before calling.
-		 *
-		 * @note	Internal method.
+		 * Calculates an element size range for the provided child of the GUI panel. Will return cached bounds so make sure
+		 * to update optimal size ranges before calling.
 		 */
 		LayoutSizeRange _getElementSizeRange(const GUIElementBase* element) const;
 
-		/**
-		 * @brief	Assigns the specified layout information to a child element of a GUI panel.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Assigns the specified layout information to a child element of a GUI panel. */
 		void _updateChildLayout(GUIElementBase* element, const GUILayoutData& data);
 
-		/**
-		 * @copydoc	GUIElementBase::_updateLayoutInternal
-		 */
+		/** @copydoc GUIElementBase::_updateLayoutInternal */
 		void _updateLayoutInternal(const GUILayoutData& data) override;
 
 		/**
-		 * @brief	Updates the provided depth range by taking into consideration the depth range of the panel.
-		 * 			This depth range should be passed on to child elements of the panel.
+		 * Updates the provided depth range by taking into consideration the depth range of the panel. This depth range
+		 * should be passed on to child elements of the panel.
 		 */
 		void _updateDepthRange(GUILayoutData& data);
 
-		/**
-		 * @brief	Changes values that control at which depth is GUI panel and its children rendered.
-		 *
-		 * @param	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
-		 *							rendered in front of panels with higher depth. Provided depth is relative
-		 *							to depth of the parent GUI panel (if any).
-		 * @param	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 * @param	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 */
-		void setDepthRange(INT16 depth = 0, UINT16 depthRangeMin = -1, UINT16 depthRangeMax = -1);
-
-		/**
-		 * @brief	Creates a new GUI panel.
-		 *
-		 * @param	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
-		 *							rendered in front of panels with higher depth. Provided depth is relative
-		 *							to depth of the parent GUI panel (if any).
-		 * @param	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 * @param	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 */
-		static GUIPanel* create(INT16 depth = 0, UINT16 depthRangeMin = -1, UINT16 depthRangeMax = -1);
-
-		/**
-		 * @brief	Creates a new GUI panel.
-		 *
-		 * @param	depth		Determines rendering order of the GUI panel. Panels with lower depth will be
-		 *						rendered in front of panels with higher depth. Provided depth is relative
-		 *						to depth of the parent GUI panel (if any).
-		 */
-		static GUIPanel* create(const GUIOptions& options);
-
-		/**
-		 * @brief	Creates a new GUI panel.
-		 *
-		 * @param	depth			Determines rendering order of the GUI panel. Panels with lower depth will be
-		 *							rendered in front of panels with higher depth. Provided depth is relative
-		 *							to depth of the parent GUI panel (if any).
-		 * @param	depthRangeMin	Minimum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 * @param	depthRangeMax	Maximum range of depths that children of this GUI panel can have. If any panel has depth
-		 *							outside of the range [depth - depthRangeMin, depth + depthRangeMax] it will be clamped to
-		 *							nearest extreme. Value of -1 means infinite range.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 */
-		static GUIPanel* create(INT16 depth, UINT16 depthRangeMin, UINT16 depthRangeMax, const GUIOptions& options);
+		/** @endcond */
 
 	protected:
 		INT16 mDepthOffset;
 		UINT16 mDepthRangeMin;
 		UINT16 mDepthRangeMax;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIProgressBar.h

@@ -8,82 +8,71 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	GUI element containing a background image and a fill image that
-	 *			is scaled depending on the percentage set by the caller.
+	 * GUI element containing a background image and a fill image that is scaled depending on the percentage set by the
+	 * caller.
 	 */
 	class BS_EXPORT GUIProgressBar : public GUIElementContainer
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
-		/**
-		 * @brief	Name of the style for the fill image used by the progress bar.
-		 */
+		/**	Name of the style for the fill image used by the progress bar. */
 		static const String& getBarStyleType();
 
-		/**
-		 * @brief	Name of the style for the background image used by the progress bar.
-		 */
+		/**	Name of the style for the background image used by the progress bar. */
 		static const String& getBackgroundStyleType();
 
 		/**
-		 * @brief	Creates a new progress bar.
+		 * Creates a new progress bar.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIProgressBar* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new progress bar.
+		 * Creates a new progress bar.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIProgressBar* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Fills up the progress bar up to the specified percentage.
+		 * Fills up the progress bar up to the specified percentage.
 		 *
-		 * @param	pct	How far to extend the fill image, in percent ranging [0.0f, 1.0f]
+		 * @param[in]	pct	How far to extend the fill image, in percent ranging [0.0f, 1.0f]
 		 */
 		void setPercent(float pct);
 
-		/**
-		 * @brief	Gets the percentage of how full is the progress bar currently.
-		 */
+		/**	Gets the percentage of how full is the progress bar currently. */
 		float getPercent() const { return mPercent; }
 
-		/**
-		 * @copydoc	GUIElement::setTint
-		 */
+		/** @copydoc GUIElement::setTint */
 		virtual void setTint(const Color& color) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_getOptimalSize
-		 */
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElementContainer::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
 
-		Event<void(float percent)> onChanged;
+		/** @endcond */
 	protected:
 		GUIProgressBar(const String& styleName, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIElementContainer::_updateLayoutInternal
-		 */
+		/** @copydoc GUIElementContainer::_updateLayoutInternal */
 		virtual void _updateLayoutInternal(const GUILayoutData& data) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::styleUpdated
-		 */
+		/** @copydoc GUIElementContainer::styleUpdated */
 		void styleUpdated() override;
 
 	private:
@@ -92,4 +81,6 @@ namespace BansheeEngine
 
 		float mPercent;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIRenderTexture.h

@@ -7,6 +7,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
 	 * Allows you to display a render texture in the GUI. Has the same functionality as GUITexture, but also forwards any 
 	 * input to underlying GUI elements being rendered on the provided render texture.
@@ -59,13 +63,15 @@ namespace BansheeEngine
 		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the 
 		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
-		static GUIRenderTexture* create(const RenderTexturePtr& texture, const GUIOptions& options, const String& styleName = StringUtil::BLANK);
+		static GUIRenderTexture* create(const RenderTexturePtr& texture, const GUIOptions& options, 
+			const String& styleName = StringUtil::BLANK);
 
 		/** Changes the active render texture whose contents to display in the GUI element. */
 		void setRenderTexture(const RenderTexturePtr& texture);
 
 	protected:
-		GUIRenderTexture(const String& styleName, const RenderTexturePtr& texture, bool transparent, const GUIDimensions& dimensions);
+		GUIRenderTexture(const String& styleName, const RenderTexturePtr& texture, bool transparent, 
+			const GUIDimensions& dimensions);
 		virtual ~GUIRenderTexture();
 
 		/** @copydoc GUIElement::updateRenderElementsInternal */
@@ -74,4 +80,6 @@ namespace BansheeEngine
 		RenderTexturePtr mSourceTexture;
 		bool mTransparent;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIScrollArea.h

@@ -7,9 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Scroll bar options for a GUI scroll area.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Scroll bar options for a GUI scroll area. */
 	enum class ScrollBarType
 	{
 		ShowIfDoesntFit,
@@ -17,209 +19,165 @@ namespace BansheeEngine
 		NeverShow
 	};
 
-	/**
-	 * @brief	A GUI element container with support for vertical & horizontal scrolling.
-	 */
+	/**	A GUI element container with support for vertical & horizontal scrolling. */
 	class BS_EXPORT GUIScrollArea : public GUIElementContainer
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles. */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new empty scroll area.
+		 * Creates a new empty scroll area.
 		 *
-		 * @param	vertBarType		Vertical scrollbar options.
-		 * @param	horzBarType		Horizontal scrollbar options.
-		 * @param	scrollBarStyle	(Optional) Style used by the scroll bars.
-		 * @param	scrollAreaStyle	(Optional) Style used by the scroll content area.
+		 * @param[in]	vertBarType		Vertical scrollbar options.
+		 * @param[in]	horzBarType		Horizontal scrollbar options.
+		 * @param[in]	scrollBarStyle	Style used by the scroll bars.
+		 * @param[in]	scrollAreaStyle	Style used by the scroll content area.
 		 */
 		static GUIScrollArea* create(ScrollBarType vertBarType, ScrollBarType horzBarType, 
 			const String& scrollBarStyle = StringUtil::BLANK, const String& scrollAreaStyle = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new empty scroll area.
+		 * Creates a new empty scroll area.
 		 *
-		 * @param	vertBarType		Vertical scrollbar options.
-		 * @param	horzBarType		Horizontal scrollbar options.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	scrollBarStyle	(Optional) Style used by the scroll bars.
-		 * @param	scrollAreaStyle	(Optional) Style used by the scroll content area.
+		 * @param[in]	vertBarType		Vertical scrollbar options.
+		 * @param[in]	horzBarType		Horizontal scrollbar options.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	scrollBarStyle	Style used by the scroll bars.
+		 * @param[in]	scrollAreaStyle	Style used by the scroll content area.
 		 */
 		static GUIScrollArea* create(ScrollBarType vertBarType, ScrollBarType horzBarType, 
 			const GUIOptions& options, const String& scrollBarStyle = StringUtil::BLANK, 
 			const String& scrollAreaStyle = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new empty scroll area. Scroll bars will be show if needed and hidden otherwise.
+		 * Creates a new empty scroll area. Scroll bars will be show if needed and hidden otherwise.
 		 *
-		 * @param	scrollBarStyle	(Optional) Style used by the scroll bars.
-		 * @param	scrollAreaStyle	(Optional) Style used by the scroll content area.
+		 * @param[in]	scrollBarStyle	Style used by the scroll bars.
+		 * @param[in]	scrollAreaStyle	Style used by the scroll content area.
 		 */
 		static GUIScrollArea* create(const String& scrollBarStyle = StringUtil::BLANK, 
 			const String& scrollAreaStyle = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new empty scroll area. Scroll bars will be show if needed and hidden otherwise.
+		 * Creates a new empty scroll area. Scroll bars will be show if needed and hidden otherwise.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	scrollBarStyle	(Optional) Style used by the scroll bars.
-		 * @param	scrollAreaStyle	(Optional) Style used by the scroll content area.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	scrollBarStyle	Style used by the scroll bars.
+		 * @param[in]	scrollAreaStyle	Style used by the scroll content area.
 		 */
 		static GUIScrollArea* create(const GUIOptions& options, const String& scrollBarStyle = StringUtil::BLANK, 
 			const String& scrollAreaStyle = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIElementContainer::getElementType
-		 */
+		/** @copydoc GUIElementContainer::getElementType */
 		virtual ElementType _getElementType() const override { return ElementType::ScrollArea; }
 
-		/**
-		 * @brief	Returns the scroll area layout that you may use to add elements inside the scroll area.
-		 */
+		/**	Returns the scroll area layout that you may use to add elements inside the scroll area. */
 		GUILayout& getLayout() const { return *mContentLayout; }
 
-		/**
-		 * @brief	Scrolls the area up by specified amount of pixels, if possible.
-		 */
+		/**	Scrolls the area up by specified amount of pixels, if possible. */
 		void scrollUpPx(UINT32 pixels);
 
-		/**
-		 * @brief	Scrolls the area down by specified amount of pixels, if possible.
-		 */
+		/**	Scrolls the area down by specified amount of pixels, if possible. */
 		void scrollDownPx(UINT32 pixels);
 
-		/**
-		 * @brief	Scrolls the area left by specified amount of pixels, if possible.
-		 */
+		/**	Scrolls the area left by specified amount of pixels, if possible. */
 		void scrollLeftPx(UINT32 pixels);
 
-		/**
-		 * @brief	Scrolls the area right by specified amount of pixels, if possible.
-		 */
+		/**	Scrolls the area right by specified amount of pixels, if possible. */
 		void scrollRightPx(UINT32 pixels);
 
-		/**
-		 * @brief	Scrolls the area up by specified percentage (ranging [0, 1]), if possible.
-		 */
+		/**	Scrolls the area up by specified percentage (ranging [0, 1]), if possible. */
 		void scrollUpPct(float percent);
 
-		/**
-		 * @brief	Scrolls the area down by specified percentage (ranging [0, 1]), if possible.
-		 */
+		/**	Scrolls the area down by specified percentage (ranging [0, 1]), if possible. */
 		void scrollDownPct(float percent);
 
-		/**
-		 * @brief	Scrolls the area left by specified percentage (ranging [0, 1]), if possible.
-		 */
+		/**	Scrolls the area left by specified percentage (ranging [0, 1]), if possible. */
 		void scrollLeftPct(float percent);
 
-		/**
-		 * @brief	Scrolls the area right by specified percentage (ranging [0, 1]), if possible.
-		 */
+		/**	Scrolls the area right by specified percentage (ranging [0, 1]), if possible. */
 		void scrollRightPct(float percent);
 
 		/**
-		 * @brief	Scrolls the contents to the specified position.
-		 *			(0 meaning top-most part of the content is visible,
-		 *			and 1 meaning bottom-most part is visible)
+		 * Scrolls the contents to the specified position (0 meaning top-most part of the content is visible, and 1 meaning
+		 * bottom-most part is visible).
 		 */
 		void scrollToVertical(float pct);
 
 		/**
-		 * @brief	Scrolls the contents to the specified position.
-		 *			(0 meaning left-most part of the content is visible,
-		 *			and 1 meaning right-most part is visible)
+		 * Scrolls the contents to the specified position (0 meaning left-most part of the content is visible, and 1 meaning
+		 * right-most part is visible)
 		 */
 		void scrollToHorizontal(float pct);
 
 		/**
-		 * @brief	Returns how much is the scroll area scrolled in the vertical direction.
-		 *			Returned value represents percentage where 0 means no scrolling
-		 *			is happening, and 1 means area is fully scrolled to the bottom.
+		 * Returns how much is the scroll area scrolled in the vertical direction. Returned value represents percentage
+		 * where 0 means no scrolling is happening, and 1 means area is fully scrolled to the bottom.
 		 */
 		float getVerticalScroll() const;
 
 		/**
-		 * @brief	Returns how much is the scroll area scrolled in the horizontal direction.
-		 *			Returned value represents percentage where 0 means no scrolling
-		 *			is happening, and 1 means area is fully scrolled to the right.
+		 * Returns how much is the scroll area scrolled in the horizontal direction. Returned value represents percentage
+		 * where 0 means no scrolling is happening, and 1 means area is fully scrolled to the right.
 		 */
 		float getHorizontalScroll() const;
 
 		/**
-		 * @brief	Returns the bounds of the scroll area not including the scroll bars.
-		 *			(i.e. only the portion that contains the contents).
+		 * Returns the bounds of the scroll area not including the scroll bars (i.e. only the portion that contains the 
+		 * contents).
 		 */
 		Rect2I getContentBounds();
 
 		/**
-		 * @brief	Number of pixels the scroll bar will occupy when active. This is width
-		 *			for vertical scrollbar, and height for horizontal scrollbar.
+		 * Number of pixels the scroll bar will occupy when active. This is width for vertical scrollbar, and height for
+		 * horizontal scrollbar.
 		 */
 		static const UINT32 ScrollBarWidth;
 	protected:
 		~GUIScrollArea();
 
-		/**
-		 * @copydoc	GUIElementContainer::_getLayoutSizeRange
-		 */
+		/** @copydoc	GUIElementContainer::_getLayoutSizeRange */
 		virtual LayoutSizeRange _getLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc GUIElementContainer::updateBounds
-		 */
+		/** @copydoc GUIElementContainer::updateBounds */
 		virtual void updateClippedBounds() override;
 
-		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
-		 */
+		/** @copydoc	GUIElementBase::_calculateLayoutSizeRange */
 		LayoutSizeRange _calculateLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc	GUIElementBase::_updateOptimalLayoutSizes
-		 */
+		/** @copydoc GUIElementBase::_updateOptimalLayoutSizes */
 		void _updateOptimalLayoutSizes() override;
 
-		/**
-		 * @copydoc GUIElementContainer::_getOptimalSize
-		 */
+		/** @copydoc GUIElementContainer::_getOptimalSize */
 		Vector2I _getOptimalSize() const override;
 	private:
 		GUIScrollArea(ScrollBarType vertBarType, ScrollBarType horzBarType, 
 			const String& scrollBarStyle, const String& scrollAreaStyle, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIElementContainer::mouseEvent
-		 */
+		/** @copydoc GUIElementContainer::mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
 		/**
-		 * @brief	Called when the vertical scrollbar moves. 
+		 * Called when the vertical scrollbar moves. 
 		 *
-		 * @param	pct	Scrollbar position ranging [0, 1].
+		 * @param[in]	pct	Scrollbar position ranging [0, 1].
 		 */
 		void vertScrollUpdate(float pct);
 
 		/**
-		 * @brief	Called when the horizontal scrollbar moves. 
+		 * Called when the horizontal scrollbar moves. 
 		 *
-		 * @param	pct	Scrollbar position ranging [0, 1].
+		 * @param[in]	pct	Scrollbar position ranging [0, 1].
 		 */
 		void horzScrollUpdate(float pct);
 
-		/**
-		 * @copydoc	GUIElementContainer::_updateLayoutInternal
-		 */
+		/** @copydoc	GUIElementContainer::_updateLayoutInternal */
 		void _updateLayoutInternal(const GUILayoutData& data) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_getElementAreas
-		 */
+		/** @copydoc	GUIElementContainer::_getElementAreas */
 		void _getElementAreas(const Rect2I& layoutArea, Rect2I* elementAreas, UINT32 numElements, 
 			const Vector<LayoutSizeRange>& sizeRanges, const LayoutSizeRange& mySizeRange) const override;
 
@@ -253,4 +211,6 @@ namespace BansheeEngine
 		static const UINT32 MinHandleSize;
 		static const UINT32 WheelScrollAmount;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIScrollBar.h

@@ -8,133 +8,108 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	GUI element representing an element with a draggable handle
-	 *			of a variable size.
+	/** @addtogroup Implementation
+	 *  @{
 	 */
+
+	/** GUI element representing an element with a draggable handle of a variable size. */
 	class BS_EXPORT GUIScrollBar : public GUIElement
 	{
 	public:
-		/**
-		 * @brief	Triggered whenever the scrollbar handle is moved. Value provided
-		 *			is the handle position in percent (ranging [0, 1]).
-		 */
-		Event<void(float newPosition)> onScrollPositionChanged;
-
-		/**
-		 * @brief	Sets the size of the handle in pixels.
-		 *
-		 * @note	Internal method. Does not trigger layout update.
-		 */
-		void _setHandleSize(UINT32 size);
-
-		/**
-		 * @brief	Sets the position of the scroll handle in percent (ranging [0, 1]).
-		 *
-		 * @note	Internal method. Does not trigger layout update.
-		 */
-		void _setScrollPos(float pct);
-
-		/**
-		 * @brief	Returns the position of the scroll handle in percent (ranging [0, 1]).
-		 */
+		/**	Returns the position of the scroll handle in percent (ranging [0, 1]). */
 		float getScrollPos() const;
 
 		/**
-		 * @brief	Moves the handle by some amount. Amount is specified in the percentage
-		 * 			of the entire scrollable area. Values out of range will be clamped.
+		 * Moves the handle by some amount. Amount is specified in the percentage of the entire scrollable area. Values out
+		 * of range will be clamped.
 		 */
 		void scroll(float amount);
 
-		/**
-		 * @brief	Returns the maximum size of the scroll handle, in pixels.
-		 */
+		/**	Returns the maximum size of the scroll handle, in pixels. */
 		UINT32 getMaxHandleSize() const;
 
+		/**	Returns the maximum scrollable size the handle can move within (e.g. scroll bar length). */
+		UINT32 getScrollableSize() const;
+
+		/** @copydoc GUIElement::setTint */
+		virtual void setTint(const Color& color) override;
+
 		/**
-		 * @brief	Returns the maximum scrollable size the handle can move within (e.g. scroll bar length).
+		 * Triggered whenever the scrollbar handle is moved. Value provided is the handle position in percent 
+		 * (ranging [0, 1]).
 		 */
-		UINT32 getScrollableSize() const;
+		Event<void(float newPosition)> onScrollPositionChanged;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
 
 		/**
-		 * @copydoc	GUIElement::setTint
+		 * Sets the size of the handle in pixels.
+		 *
+		 * @note	Does not trigger layout update.
 		 */
-		virtual void setTint(const Color& color) override;
+		void _setHandleSize(UINT32 size);
 
 		/**
-		 * @copydoc	GUIElement::_getOptimalSize
+		 * @brief	Sets the position of the scroll handle in percent (ranging [0, 1]).
+		 *
+		 * @note	Does not trigger layout update.
 		 */
+		void _setScrollPos(float pct);
+
+		/** @copydoc GUIElement::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
+
+		/** @endcond */
 	protected:
 		/**
-		 * @brief	Constructs a new scrollbar.
+		 * Constructs a new scrollbar.
 		 *
-		 * @param	horizontal	If true the scroll bar will have a horizontal moving handle, otherwise
-		 *						it will be a vertical one.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
+		 * @param[in]	horizontal	If true the scroll bar will have a horizontal moving handle, otherwise it will be a
+		 *							vertical one.
+		 * @param[in]	styleName	Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *							GUIWidget the element is used on. If not specified default style is used.
+		 * @param[in]	options		Options that allow you to control how is the element positioned and sized. This will 
+		 *							override any similar options set by style.
 		 */
 		GUIScrollBar(bool horizontal, const String& styleName, const GUIDimensions& dimensions);
 		virtual ~GUIScrollBar();
 
-		/**
-		 * @copydoc GUIElement::_getNumRenderElements
-		 */
+		/** @copydoc GUIElement::_getNumRenderElements */
 		virtual UINT32 _getNumRenderElements() const override;
 
-		/**
-		 * @copydoc GUIElement::_getMaterial
-		 */
+		/** @copydoc GUIElement::_getMaterial */
 		virtual const SpriteMaterialInfo& _getMaterial(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_getNumQuads
-		 */
+		/** @copydoc GUIElement::_getNumQuads */
 		virtual UINT32 _getNumQuads(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_fillBuffer
-		 */
+		/** @copydoc GUIElement::_fillBuffer */
 		virtual void _fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
 			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::updateRenderElementsInternal
-		 */
+		/** @copydoc GUIElement::updateRenderElementsInternal */
 		virtual void updateRenderElementsInternal() override;
 
-		/**
-		 * @copydoc GUIElement::updateBounds
-		 */
+		/** @copydoc GUIElement::updateBounds */
 		virtual void updateClippedBounds() override;
 
-		/**
-		 * @copydoc GUIElement::_getRenderElementDepth
-		 */
+		/** @copydoc GUIElement::_getRenderElementDepth */
 		virtual UINT32 _getRenderElementDepth(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc	GUIElement::_getRenderElementDepthRange
-		 */
+		/** @copydoc	GUIElement::_getRenderElementDepthRange */
 		virtual UINT32 _getRenderElementDepthRange() const override;
 	private:
 		/**
-		 * @brief	Triggered whenever the scroll handle moves. Provided value represents the new 
-		 *			position of the handle in percent (ranging [0, 1]).
+		 * Triggered whenever the scroll handle moves. Provided value represents the new position of the handle in percent
+		 * (ranging [0, 1]).
 		 */
 		void handleMoved(float handlePct);
 
-		/**
-		 * @brief	Triggered when scroll up button is clicked.
-		 */
+		/**	Triggered when scroll up button is clicked. */
 		void upButtonClicked();
 
-		/**
-		 * @brief	Triggered when scroll down button is clicked.
-		 */
+		/**	Triggered when scroll down button is clicked. */
 		void downButtonClicked();
 
 		GUILayout* mLayout;
@@ -147,4 +122,6 @@ namespace BansheeEngine
 
 		static const UINT32 ButtonScrollAmount;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIScrollBarHorz.h

@@ -7,38 +7,38 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Specialization of a horizontal scroll bar.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Specialization of a GUIScrollBar for horizontal scrolling. */
 	class BS_EXPORT GUIScrollBarHorz : public GUIScrollBar
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new horizontal scroll bar.
+		 * Creates a new horizontal scroll bar.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIScrollBarHorz* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new horizontal scroll bar.
+		 * Creates a new horizontal scroll bar.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIScrollBarHorz* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 	protected:
 		GUIScrollBarHorz(const String& styleName, const GUIDimensions& dimensions);
 		~GUIScrollBarHorz();
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIScrollBarVert.h

@@ -8,38 +8,38 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Specialization of a vertical scroll bar.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Specialization of a GUIScrollBar for vertical scrolling. */
 	class BS_EXPORT GUIScrollBarVert : public GUIScrollBar
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new vertical scroll bar.
+		 * Creates a new vertical scroll bar.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIScrollBarVert* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new vertical scroll bar.
+		 * Creates a new vertical scroll bar.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIScrollBarVert* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 	protected:
 		GUIScrollBarVert(const String& styleName, const GUIDimensions& dimensions);
 		~GUIScrollBarVert();
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUISkin.h

@@ -8,53 +8,52 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Holds a set of styles that control how are GUI element types positioned and
-	 *			displayed in the GUI. Each element type can be assigned a specific style.
+	 * Holds a set of styles that control how are GUI element types positioned and displayed in the GUI. Each element type
+	 * can be assigned a specific style.
 	 */
 	class BS_EXPORT GUISkin : public Resource
 	{
 	public:
-		/**
-		 * @brief	Checks if the style with the specified name exists.
-		 */
+		/**	Checks if the style with the specified name exists. */
 		bool hasStyle(const String& name) const;
 
 		/**
-		 * @brief	Returns a style for the specified GUI element type.
+		 * Returns a style for the specified GUI element type.
 		 *
 		 * @see		GUIElement::getGUITypeName
 		 */
 		const GUIElementStyle* getStyle(const String& guiElemType) const;
 
 		/**
-		 * @brief	Sets a style for the specified GUI element type.
+		 * Sets a style for the specified GUI element type.
 		 *
 		 * @see		GUIElement::getGUITypeName
 		 */
 		void setStyle(const String& guiElemType, const GUIElementStyle& style);
 
 		/**
-		 * @brief	Removes a style for the specified GUI element type.
+		 * Removes a style for the specified GUI element type.
 		 *
 		 * @see		GUIElement::getGUITypeName
 		 */
 		void removeStyle(const String& guiElemType);
 
-		/**
-		 * @brief	Returns names of all styles registered on this skin.
-		 */
+		/**	Returns names of all styles registered on this skin. */
 		Vector<String> getStyleNames() const;
 
-		/**
-		 * @brief	Default style that may be used when no other is available.
-		 */
+		/**	Creates an empty GUI skin and returns a handle to it. */
+		static HGUISkin create();
+
+		/**	Default style that may be used when no other is available. */
 		static GUIElementStyle DefaultStyle;
 
-		/**
-		 * @brief	Creates an empty GUI skin and returns a handle to it.
-		 */
-		static HGUISkin create();
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
 
 		/**
 		 * @brief	Creates an empty GUI skin and returns a pointer to it.
@@ -63,6 +62,7 @@ namespace BansheeEngine
 		 */
 		static GUISkinPtr _createPtr();
 
+		/** @encond */
 	private:
 		GUISkin();
 		GUISkin(const GUISkin& skin); // Disable copying
@@ -77,4 +77,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUISlider.h

@@ -8,90 +8,78 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A slider with a draggable handle that can be vertical or horizontal.
+	/** @addtogroup Implementation
+	 *  @{
 	 */
+
+	/**	A slider with a draggable handle that can be vertical or horizontal. */
 	class BS_EXPORT GUISlider : public GUIElementContainer
 	{
 	public:
-		/**
-		 * @brief	Name of the style for the handle button used by the slider.
-		 */
+		/**	Name of the style for the handle button used by the slider. */
 		static const String& getHandleStyleType();
 
-		/**
-		 * @brief	Name of the style for the background image used by the slider.
-		 */
+		/**	Name of the style for the background image used by the slider. */
 		static const String& getBackgroundStyleType();
 
-		/**
-		 * @brief	Name of the style for the background fill image used by the slider.
-		 */
+		/**	Name of the style for the background fill image used by the slider. */
 		static const String& getFillStyleType();
 
 		/**
-		 * @brief	Moves the slider handle the the specified position in the handle area.
+		 * Moves the slider handle the the specified position in the handle area.
 		 *
-		 * @param	pct	Position to move the handle to, in percent ranging [0.0f, 1.0f]
+		 * @param[in]	pct	Position to move the handle to, in percent ranging [0.0f, 1.0f]
 		 */
 		void setPercent(float pct);
 
-		/**
-		 * @brief	Gets the current position of the slider handle, in percent ranging [0.0f, 1.0f].
-		 */
+		/**	Gets the current position of the slider handle, in percent ranging [0.0f, 1.0f]. */
 		float getPercent() const;
 
 		/**
-		 * @brief	Gets the current value of the slider. This is the slider handle position percentage scaled within
-		 * 			the current minimum and maximum range, rounded up to nearest step increment.
+		 * Gets the current value of the slider. This is the slider handle position percentage scaled within the current
+		 * minimum and maximum range, rounded up to nearest step increment.
 		 */
 		float getValue() const;
 
-		/**
-		 * @brief	Sets a new value of the slider. This value should be within minimum and maximum range values.
-		 */
+		/**	Sets a new value of the slider. This value should be within minimum and maximum range values. */
 		void setValue(float value);
 
 		/**
-		 * @brief	Sets a minimum and maximum allow values in the input field.
-		 *			Set to large negative/positive values if you don't require clamping.
+		 * Sets a minimum and maximum allow values in the input field. Set to large negative/positive values if you don't
+		 * require clamping.
 		 */
 		void setRange(float min, float max);
 
 		/**
-		 * @brief	Sets a step that defines the minimal increment the value can be increased/decreased by. Set to zero
-		 * 			to have no step.
+		 * Sets a step that defines the minimal increment the value can be increased/decreased by. Set to zero to have no
+		 * step.
 		 */
 		void setStep(float step);
 
-		/**
-		 * @copydoc	GUIElement::setTint
-		 */
+		/** @copydoc GUIElement::setTint */
 		virtual void setTint(const Color& color) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_getOptimalSize
-		 */
+		/** Triggered when the user changes the value of the slider. */
+		Event<void(float percent)> onChanged;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElementContainer::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
 
-		Event<void(float percent)> onChanged;
+		/** @endcond */
 	protected:
 		GUISlider(bool horizontal, const String& styleName, const GUIDimensions& dimensions);
 		virtual ~GUISlider();
 
-		/**
-		 * @copydoc	GUIElementContainer::_updateLayoutInternal
-		 */
+		/** @copydoc GUIElementContainer::_updateLayoutInternal */
 		virtual void _updateLayoutInternal(const GUILayoutData& data) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::styleUpdated
-		 */
+		/** @copydoc GUIElementContainer::styleUpdated */
 		void styleUpdated() override;
 
-		/**
-		 * @brief	Triggered when the slider handles moves.
-		 */
+		/**	Triggered when the slider handles moves. */
 		void onHandleMoved(float newPosition);
 
 	private:
@@ -105,34 +93,34 @@ namespace BansheeEngine
 		HEvent mHandleMovedConn;
 	};
 
-	/**
-	 * @brief	A horizontal slider with a draggable handle.
+	/** @} */
+
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	A horizontal slider with a draggable handle. */
 	class BS_EXPORT GUISliderHorz : public GUISlider
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new horizontal slider.
+		 * Creates a new horizontal slider.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderHorz* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new horizontal slider.
+		 * Creates a new horizontal slider.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderHorz* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
@@ -140,38 +128,34 @@ namespace BansheeEngine
 		GUISliderHorz(const String& styleName, const GUIDimensions& dimensions);
 	};
 
-	/**
-	 * @brief	A vertical slider with a draggable handle.
-	 */
+	/**	A vertical slider with a draggable handle. */
 	class BS_EXPORT GUISliderVert : public GUISlider
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new vertical slider.
+		 * Creates a new vertical slider.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderVert* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new vertical slider.
+		 * Creates a new vertical slider.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderVert* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 	private:
 		GUISliderVert(const String& styleName, const GUIDimensions& dimensions);
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUISliderHandle.h

@@ -9,158 +9,129 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A handle that can be dragged from its predefined minimum and maximum position,
-	 *			either horizontally or vertically.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** A handle that can be dragged from its predefined minimum and maximum position, either horizontally or vertically. */
 	class BS_EXPORT GUISliderHandle : public GUIElement
 	{
-		/**
-		 * @brief	Visual state of the handle
-		 */
+		/**	Visual state of the handle. */
 		enum class State
 		{
 			Normal, Hover, Active
 		};
 
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new handle.
+		 * Creates a new handle.
 		 *
-		 * @param	horizontal		Should the handle be movable vertically or horizontally.
-		 * @param	jumpOnClick		If true clicking on a specific position on the slider will cause
-		 *							the slider handle to jump to that position. Otherwise the slider
-		 *							will just slightly move towards that direction.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	horizontal		Should the handle be movable vertically or horizontally.
+		 * @param[in]	jumpOnClick		If true clicking on a specific position on the slider will cause the slider handle
+		 *								to jump to that position. Otherwise the slider will just slightly move towards that
+		 *								direction.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderHandle* create(bool horizontal, bool jumpOnClick, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new handle.
+		 * Creates a new handle.
 		 *
-		 * @param	horizontal		Should the handle be movable vertically or horizontally.
-		 * @param	jumpOnClick		If true clicking on a specific position on the slider will cause
-		 *							the slider handle to jump to that position. Otherwise the slider
-		 *							will just slightly move towards that direction.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	horizontal		Should the handle be movable vertically or horizontally.
+		 * @param[in]	jumpOnClick		If true clicking on a specific position on the slider will cause the slider handle
+		 *								to jump to that position. Otherwise the slider will just slightly move towards that
+		 *								direction.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUISliderHandle* create(bool horizontal, bool jumpOnClick, const GUIOptions& options,
 			const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @brief	Size of the handle in pixels, along the handle drag direction.
-		 *
-		 * @note	Internal method. Does not trigger layout update.
-		 */
-		void _setHandleSize(UINT32 size);
-
-		/**
-		 * @brief	Moves the handle the the specified position in the handle area.
-		 *
-		 * @param	pct	Position to move the handle to, in percent ranging [0.0f, 1.0f]
-		 *
-		 * @note	Internal method. Does not trigger layout update.
-		 */
-		void _setHandlePos(float pct);
-
-		/**
-		 * @brief	Gets the current position of the handle, in percent ranging [0.0f, 1.0f].
-		 */
+		/**	Gets the current position of the handle, in percent ranging [0.0f, 1.0f]. */
 		float getHandlePos() const;
 
-		/**
-		 * @brief	Returns the position of the slider handle, in pixels. Relative to this object.
-		 */
+		/**	Returns the position of the slider handle, in pixels. Relative to this object. */
 		INT32 getHandlePosPx() const;
 
-		/**
-		 * @brief	Returns remaining length of the scrollable area not covered by the handle, in pixels.
-		 */
+		/**	Returns remaining length of the scrollable area not covered by the handle, in pixels. */
 		UINT32 getScrollableSize() const;
 
-		/**
-		 * @brief	Returns the total length of the area the handle can move in, in pixels.
-		 */
+		/**	Returns the total length of the area the handle can move in, in pixels. */
 		UINT32 getMaxSize() const;
 
-		/**
-		 * @brief	Sets a step that defines the minimal increment the value can be increased/decreased by. Set to zero
-		 * 			to have no step.
+		/**	
+		 * Sets a step that defines the minimal increment the value can be increased/decreased by. Set to zero	to have no
+		 * step.
 		 */
 		void setStep(float step);
 
+		/** Triggered when the user drags the handle. */
+		Event<void(float newPosition)> onHandleMoved;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
 		/**
-		 * @copydoc	GUIElement::_getOptimalSize
+		 * Size of the handle in pixels, along the handle drag direction.
+		 *
+		 * @note	Internal method. Does not trigger layout update.
 		 */
+		void _setHandleSize(UINT32 size);
+
+		/**
+		 * Moves the handle the the specified position in the handle area.
+		 *
+		 * @param[in]	pct	Position to move the handle to, in percent ranging [0.0f, 1.0f]
+		 *
+		 * @note	Internal method. Does not trigger layout update.
+		 */
+		void _setHandlePos(float pct);
+
+		/** @copydoc GUIElement::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
 
-		Event<void(float newPosition)> onHandleMoved;
+		/** @endcond */
 	protected:
 		~GUISliderHandle();
 
-		/**
-		 * @copydoc GUIElement::_getNumRenderElements()
-		 */
+		/** @copydoc GUIElement::_getNumRenderElements() */
 		virtual UINT32 _getNumRenderElements() const override;
 
-		/**
-		 * @copydoc GUIElement::_getMaterial()
-		 */
+		/** @copydoc GUIElement::_getMaterial() */
 		virtual const SpriteMaterialInfo& _getMaterial(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_getNumQuads()
-		 */
+		/** @copydoc GUIElement::_getNumQuads() */
 		virtual UINT32 _getNumQuads(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_fillBuffer()
-		 */
+		/** @copydoc GUIElement::_fillBuffer() */
 		virtual void _fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
 			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::updateRenderElementsInternal()
-		 */
+		/** @copydoc GUIElement::updateRenderElementsInternal() */
 		virtual void updateRenderElementsInternal() override;
 
-		/**
-		 * @copydoc GUIElement::updateBounds()
-		 */
+		/** @copydoc GUIElement::updateBounds() */
 		virtual void updateClippedBounds() override;
 	private:
 		GUISliderHandle(bool horizontal, bool jumpOnClick, const String& styleName, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIElement::mouseEvent
-		 */
+		/** @copydoc GUIElement::mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
-		/**
-		 * @brief	Checks are the specified over the scroll handle. Coordinates are relative
-		 *			to the parent widget.
-		 */
+		/** Checks are the specified over the scroll handle. Coordinates are relative to the parent widget. */
 		bool isOnHandle(const Vector2I& pos) const;
 
-		/**
-		 * @brief	Sets the position of the slider handle, in pixels. Relative to this object. For internal use only.
-		 */
+		/**	Sets the position of the slider handle, in pixels. Relative to this object. For internal use only. */
 		void setHandlePosPx(INT32 pos);
 
-		/**
-		 * @brief	Gets the currently active texture, depending on handle state.
-		 */
+		/**	Gets the currently active texture, depending on handle state. */
 		const HSpriteTexture& getActiveTexture() const;
 
 		ImageSprite* mImageSprite;
@@ -175,4 +146,7 @@ namespace BansheeEngine
 		bool mHandleDragged;
 		State mState;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUISpace.h

@@ -7,10 +7,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	GUI element that may be inserted into layouts in order to make
-	 *			a space of a fixed size.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** GUI element that may be inserted into layouts in order to make a space of a fixed size. */
 	class BS_EXPORT GUIFixedSpace : public GUIElementBase
 	{
 	public:
@@ -20,64 +21,51 @@ namespace BansheeEngine
 
 		~GUIFixedSpace();
 
-		/**
-		 * @brief	Returns the size of the space in pixels.
-		 */
+		/**	Returns the size of the space in pixels. */
 		UINT32 getSize() const { return mSize; }
 
-		/**
-		 * @brief	Changes the size of the space to the specified value, in pixels.
-		 */
+		/**	Changes the size of the space to the specified value, in pixels. */
 		void setSize(UINT32 size) { if (mSize != size) { mSize = size; _markLayoutAsDirty(); } }
 
-		/**
-		 * @copydoc	GUIElementBase::_getType
-		 */
+		/**	Creates a new fixed space GUI element. */
+		static GUIFixedSpace* create(UINT32 size);
+
+		/**	Destroys the space and removes it from its parent. */
+		static void destroy(GUIFixedSpace* space);
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElementBase::_getType */
 		Type _getType() const override { return GUIElementBase::Type::FixedSpace; }
 
-		/**
-		 * @copydoc	GUIElementBase::_getOptimalSize
-		 */
-		virtual Vector2I _getOptimalSize() const override { return Vector2I(getSize(), getSize()); }
+		/** @copydoc GUIElementBase::_getOptimalSize */
+		Vector2I _getOptimalSize() const override { return Vector2I(getSize(), getSize()); }
 
-		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
-		 */
-		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
+		/** @copydoc GUIElementBase::_calculateLayoutSizeRange */
+		LayoutSizeRange _calculateLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc	GUIElementBase::_getPadding
-		 */
-		virtual const RectOffset& _getPadding() const  override
+		/** @copydoc GUIElementBase::_getPadding */
+		const RectOffset& _getPadding() const override
 		{
 			static RectOffset padding;
 
 			return padding;
 		}
 
-		/**
-		 * @brief	Creates a new fixed space GUI element.
-		 */
-		static GUIFixedSpace* create(UINT32 size);
-
-		/**
-		 * @brief	Destroys the space and removes it from its parent.
-		 */
-		static void destroy(GUIFixedSpace* space);
-
+		/** @endcond */
 	protected:
 		UINT32 mSize;
 	};
 
 	/**
-	 * @brief	GUI element that may be inserted into layouts to make a space of
-	 *			a flexible size. The space will expand only if there is room and
-	 *			other elements are not squished because of it. If multiple flexible
-	 *			spaces are in a layout, their sizes will be shared equally.
+	 * GUI element that may be inserted into layouts to make a space of a flexible size. The space will expand only if 
+	 * there is room and other elements are not squished because of it. If multiple flexible spaces are in a layout, their
+	 * sizes will be shared equally.
 	 *
-	 * @note	e.g. If you had a horizontal layout with a button, and you wanted to
-	 *			align that button to the right of the layout, you would insert a flexible
-	 *			space before the button in the layout.
+	 * @note	
+	 * e.g. If you had a horizontal layout with a button, and you wanted to align that button to the right of the layout,
+	 * you would insert a flexible space before the button in the layout.
 	 */
 	class BS_EXPORT GUIFlexibleSpace : public GUIElementBase
 	{
@@ -85,24 +73,25 @@ namespace BansheeEngine
 		GUIFlexibleSpace() {}
 		~GUIFlexibleSpace();
 
-		/**
-		 * @copydoc	GUIElementBase::_getType
-		 */
+		/**	Creates a new flexible space GUI element. */
+		static GUIFlexibleSpace* create();
+
+		/**	Destroys the space and removes it from its parent. */
+		static void destroy(GUIFlexibleSpace* space);
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElementBase::_getType */
 		Type _getType() const override { return GUIElementBase::Type::FlexibleSpace; }
 
-		/**
-		 * @copydoc	GUIElementBase::_getOptimalSize
-		 */
+		/** @copydoc GUIElementBase::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override { return Vector2I(0, 0); }
 
-		/**
-		 * @copydoc	GUIElementBase::_calculateLayoutSizeRange
-		 */
+		/** @copydoc GUIElementBase::_calculateLayoutSizeRange */
 		virtual LayoutSizeRange _calculateLayoutSizeRange() const override;
 
-		/**
-		 * @copydoc	GUIElementBase::_getPadding
-		 */
+		/** @copydoc GUIElementBase::_getPadding */
 		virtual const RectOffset& _getPadding() const override
 		{
 			static RectOffset padding;
@@ -110,14 +99,8 @@ namespace BansheeEngine
 			return padding;
 		}
 
-		/**
-		 * @brief	Creates a new flexible space GUI element.
-		 */
-		static GUIFlexibleSpace* create();
-
-		/**
-		 * @brief	Destroys the space and removes it from its parent.
-		 */
-		static void destroy(GUIFlexibleSpace* space);
+		/** @endcond */
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUITextInputEvent.h

@@ -8,26 +8,26 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A text input event representing input of a single character.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	A text input event representing input of a single character. */
 	class BS_EXPORT GUITextInputEvent
 	{
 	public:
 		GUITextInputEvent();
 
-		/**
-		 * @brief	Character code that was input.
-		 */
+		/**	Character code that was input. */
 		const UINT32& getInputChar() const { return mInputChar; }
 	private:
 		friend class GUIManager;
 
-		/**
-		 * @brief	Initializes the event data with the character that was input.
-		 */
+		/**	Initializes the event data with the character that was input. */
 		void setData(UINT32 inputChar);
 
 		UINT32 mInputChar;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUITexture.h

@@ -8,9 +8,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Type of scaling modes for GUI images.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Type of scaling modes for GUI images. */
 	enum class GUIImageScaleMode
 	{
 		StretchToFit, /**< Image will stretch non-uniformly in all dimensions in order to cover the assigned area fully. */
@@ -19,194 +21,168 @@ namespace BansheeEngine
 		RepeatToFit /**< Image will keep its original size, but will repeat in order to fill the assigned area. */
 	};
 
-	/**
-	 * @brief	A GUI element that displays a texture.
-	 */
+	/**	A GUI element that displays a texture. */
 	class BS_EXPORT GUITexture : public GUIElement
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new GUI texture element.
+		 * Creates a new GUI texture element.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	transparent		Determines should the texture be rendered with transparency active.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style
+		 *								will be used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	transparent		Determines should the texture be rendered with transparency active.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, GUIImageScaleMode scale, bool transparent,
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element.
+		 * Creates a new GUI texture element.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	transparent		Determines should the texture be rendered with transparency active.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style 
+		 *								will be used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	transparent		Determines should the texture be rendered with transparency active.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the 
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, GUIImageScaleMode scale, bool transparent,
 			const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element.
+		 * Creates a new GUI texture element.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style
+		 *								will be used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, GUIImageScaleMode scale, 
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element.
+		 * Creates a new GUI texture element.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style
+		 *								will be used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, GUIImageScaleMode scale, 
 			const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the default StretchToFit scale mode.
+		 * Creates a new GUI texture element. Uses the default StretchToFit scale mode.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style
+		 *								will be used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, 
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the default StretchToFit scale mode.
+		 * Creates a new GUI texture element. Uses the default StretchToFit scale mode.
 		 *
-		 * @param	texture			Texture element to display. If this is null then the texture specified
-		 *							by the style will be used.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	texture			Texture element to display. If this is null then the texture specified by the style
+		 *								will be used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const HSpriteTexture& texture, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
+		 * Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
 		 *
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(GUIImageScaleMode scale, const GUIOptions& options, 
 			const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
+		 * Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
 		 *
-		 * @param	scale			Scale mode to use when sizing the texture.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	scale			Scale mode to use when sizing the texture.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(GUIImageScaleMode scale, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
+		 * Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
 		 *			Uses the default StretchToFit scale mode.
 		 *
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
+		 * Creates a new GUI texture element. Uses the "normal" texture from the active GUI element style.
 		 *			Uses the default StretchToFit scale mode.
 		 *
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUITexture* create(const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Changes the active texture. If the provided texture is null 
-		 *			then the texture specified by the style will be used.
+		 * Changes the active texture. If the provided texture is null then the texture specified by the style will be used.
 		 */
 		void setTexture(const HSpriteTexture& texture);
 
-		/**
-		 * @copydoc	GUIElement::getElementType
-		 */
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElement::getElementType */
 		virtual ElementType _getElementType() const override { return ElementType::Texture; }
 
-		/**
-		 * @copydoc	GUIElement::_getOptimalSize
-		 */
+		/** @copydoc	GUIElement::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
+
+		/** @endcond */
 	protected:
 		GUITexture(const String& styleName, const HSpriteTexture& texture, GUIImageScaleMode scale, 
 			bool transparent, const GUIDimensions& dimensions);
 		virtual ~GUITexture();
 
-		/**
-		 * @copydoc GUIElement::_getNumRenderElements
-		 */
+		/** @copydoc GUIElement::_getNumRenderElements */
 		virtual UINT32 _getNumRenderElements() const override;
 
-		/**
-		 * @copydoc GUIElement::_getMaterial
-		 */
+		/** @copydoc GUIElement::_getMaterial */
 		virtual const SpriteMaterialInfo& _getMaterial(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_getNumQuads
-		 */
+		/** @copydoc GUIElement::_getNumQuads */
 		virtual UINT32 _getNumQuads(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_fillBuffer
-		 */
+		/** @copydoc GUIElement::_fillBuffer */
 		virtual void _fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
 			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::updateRenderElementsInternal
-		 */
+		/** @copydoc GUIElement::updateRenderElementsInternal */
 		virtual void updateRenderElementsInternal() override;
 
-		/**
-		 * @copydoc GUIElement::styleUpdated
-		 */
+		/** @copydoc GUIElement::styleUpdated */
 		virtual void styleUpdated() override;
 
 		ImageSprite* mImageSprite;
@@ -216,4 +192,6 @@ namespace BansheeEngine
 		bool mTransparent;
 		bool mUsingStyleTexture;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIToggle.h

@@ -12,127 +12,108 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	GUI element representing a toggle (on/off) button.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	GUI element representing a toggle (on/off) button. */
 	class BS_EXPORT GUIToggle : public GUIButtonBase
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new toggle button with the specified label.
+		 * Creates a new toggle button with the specified label.
 		 *
-		 * @param	text			Label to display in the button, if any.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	text			Label to display in the button, if any.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIToggle* create(const HString& text, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new toggle button with the specified label.
+		 * Creates a new toggle button with the specified label.
 		 *
-		 * @param	text			Label to display in the button, if any.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	text			Label to display in the button, if any.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIToggle* create(const HString& text, const GUIOptions& options, 
 			const String& styleName = StringUtil::BLANK);
 	
 		/**
-		 * @brief	Creates a new toggle button with the specified label.
+		 * Creates a new toggle button with the specified label.
 		 *
-		 * @param	text			Label to display in the button, if any.
-		 * @param	toggleGroup		Toggle group this button belongs to.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	text			Label to display in the button, if any.
+		 * @param[in]	toggleGroup		Toggle group this button belongs to.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIToggle* create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, 
 			const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new toggle button with the specified label.
+		 * Creates a new toggle button with the specified label.
 		 *
-		 * @param	text			Label to display in the button, if any.
-		 * @param	toggleGroup		Toggle group this button belongs to.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	text			Label to display in the button, if any.
+		 * @param[in]	toggleGroup		Toggle group this button belongs to.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized.
+		 *								This will override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 */
 		static GUIToggle* create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, 
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIToggle::create(const HString& text, const String& styleName)
-		 */
+		/** @copydoc GUIToggle::create(const HString& text, const String& styleName) */
 		static GUIToggle* create(const GUIContent& content, const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIToggle::create(const HString& text, const GUIOptions& options, const String& styleName)
-		 */
+		/** @copydoc GUIToggle::create(const HString& text, const GUIOptions& options, const String& styleName) */
 		static GUIToggle* create(const GUIContent& content, const GUIOptions& options, 
 			const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIToggle::create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const String& styleName)
-		 */
+		/** @copydoc GUIToggle::create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const String& styleName) */
 		static GUIToggle* create(const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, 
 			const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIToggle::create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& options, const String& styleName)
-		 */
+		/** @copydoc GUIToggle::create(const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& options, const String& styleName) */
 		static GUIToggle* create(const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, 
 			const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a toggle group that you may provide to GUIToggle upon construction. Toggles sharing the
-		 *			same group will only have a single element active at a time.
+		 * Creates a toggle group that you may provide to GUIToggle upon construction. Toggles sharing the same group will
+		 * only have a single element active at a time.
 		 *
-		 * @param	allowAllOff	If true all of the toggle buttons can be turned off, if false one will always be turned on.
+		 * @param[in]	allowAllOff	If true all of the toggle buttons can be turned off, if false one will always be turned 
+		 *							on.
 		 */
 		static std::shared_ptr<GUIToggleGroup> createToggleGroup(bool allowAllOff = false);
 
-		/**
-		 * @brief	Checks the toggle, making it active.
-		 */
+		/**	Checks the toggle, making it active. */
 		virtual void toggleOn();
 
-		/**
-		 * @brief	Unchecks the toggle, making it inactive.
-		 */
+		/**	Unchecks the toggle, making it inactive. */
 		virtual void toggleOff();
 
-		/**
-		 * @brief	Checks is the toggle currently on.
-		 */
+		/**	Checks is the toggle currently on. */
 		bool isToggled() const { return mIsToggled; }
 
-		/**
-		 * @copydoc	GUIButtonBase::getElementType
-		 */
+		/**	Triggered whenever the button is toggled on or off. */
+		Event<void(bool)> onToggled;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIButtonBase::getElementType */
 		virtual ElementType _getElementType() const override { return ElementType::Toggle; }
 
-		/**
-		 * @brief	Sets a toggle group of the toggle button. Toggling one button in a group will
-		 *			automatically untoggle others.
-		 */
+		/** Sets a toggle group of the toggle button. Toggling one button in a group will automatically untoggle others. */
 		void _setToggleGroup(std::shared_ptr<GUIToggleGroup> toggleGroup);
 
-		/**
-		 * @brief	Triggered whenever the button is toggled on or off.
-		 */
-		Event<void(bool)> onToggled;
+		/** @endcond */
 	protected:
 		virtual ~GUIToggle();
 
@@ -140,13 +121,13 @@ namespace BansheeEngine
 		GUIToggle(const String& styleName, const GUIContent& content, 
 			std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIButtonBase::mouseEvent
-		 */
+		/** @copydoc GUIButtonBase::mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
 	protected:
 		std::shared_ptr<GUIToggleGroup> mToggleGroup;
 		bool mIsToggled;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIToggleGroup.h

@@ -6,41 +6,38 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Object that allows you to group multiple GUI toggle buttons.
-	 *			Only one button among the grouped ones can be active.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** Object that allows you to group multiple GUI toggle buttons. Only one button among the grouped ones can be active. */
 	class BS_EXPORT GUIToggleGroup
 	{
 	public:
 		~GUIToggleGroup();
 
-		/**
-		 * @brief	Registers a new toggle button with the group.
-		 *
-		 * @note	Internal method.
-		 */
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** Registers a new toggle button with the group. */
 		void _add(GUIToggle* toggle);
 
-		/**
-		 * @brief	Unregisters a toggle button from the group.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Unregisters a toggle button from the group. */
 		void _remove(GUIToggle* toggle);
 
+		/** @endcond */
 	private:
 		friend class GUIToggle;
 
 		GUIToggleGroup(bool allowAllOff);
 
-		/**
-		 * @brief	Initializes the toggle group. To be called right after construction.
-		 */
+		/**	Initializes the toggle group. To be called right after construction. */
 		void initialize(const std::shared_ptr<GUIToggleGroup>& sharedPtr);
 
 		Vector<GUIToggle*> mButtons;
 		bool mAllowAllOff;
 		std::weak_ptr<GUIToggleGroup> mThis;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUITooltip.h

@@ -7,24 +7,25 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	GUI widget that renders a tooltip overlaid over other GUI elements.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	GUI widget that renders a tooltip overlaid over other GUI elements. */
 	class BS_EXPORT GUITooltip : public CGUIWidget
 	{
 	public:
-		/**
-		 * @brief	Name of the style used for tooltip's background frame.
-		 */
+		/**	Name of the style used for tooltip's background frame. */
 		static String getFrameStyleName();
 
 		/**
-		 * @brief	Creates a new tooltip widget.
+		 * Creates a new tooltip widget.
 		 *
-		 * @param	parent			Parent scene object to attach the tooltip to.
-		 * @param	overlaidWidget	Widget over which to overlay the tooltip.
-		 * @param	position		Position of the tooltip, relative to the overlaid widget position.
-		 * @param	text			Text to display in the tooltip.
+		 * @param[in]	parent			Parent scene object to attach the tooltip to.
+		 * @param[in]	overlaidWidget	Widget over which to overlay the tooltip.
+		 * @param[in]	position		Position of the tooltip, relative to the overlaid widget position.
+		 * @param[in]	text			Text to display in the tooltip.
 		 */
 		GUITooltip(const HSceneObject& parent, const GUIWidget& overlaidWidget, const Vector2I& position, const WString& text);
 		~GUITooltip();
@@ -33,4 +34,7 @@ namespace BansheeEngine
 		static const UINT32 TOOLTIP_WIDTH;
 		static const UINT32 CURSOR_SIZE;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUITooltipManager.h

@@ -7,29 +7,33 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Manages displaying tooltips over GUI elements.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Manages displaying tooltips over GUI elements. */
 	class BS_EXPORT GUITooltipManager : public Module<GUITooltipManager>
 	{
 	public:
 		~GUITooltipManager();
 
 		/**
-		 * @brief	Shows a tooltip at the specified location. This will replace any previously shown tooltip.
+		 * Shows a tooltip at the specified location. This will replace any previously shown tooltip.
 		 *
-		 * @param	widget		GUI widget over which to display the tooltip.
-		 * @param	position	Position of the tooltip, relative to the parent GUI widget.
-		 * @param	text		Text to display on the tooltip.
+		 * @param[in]	widget		GUI widget over which to display the tooltip.
+		 * @param[in]	position	Position of the tooltip, relative to the parent GUI widget.
+		 * @param[in]	text		Text to display on the tooltip.
 		 */
 		void show(const GUIWidget& widget, const Vector2I& position, const WString& text);
 
-		/**
-		 * @brief	Hides the currently shown tooltip.
-		 */
+		/**	Hides the currently shown tooltip. */
 		void hide();
 
 	private:
 		HSceneObject mTooltipSO;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIViewport.h

@@ -8,95 +8,82 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Displays a Camera view in the form of a GUI element.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Displays a Camera view in the form of a GUI element. */
 	class BS_EXPORT GUIViewport : public GUIElement
 	{
 	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
 		static const String& getGUITypeName();
 
 		/**
-		 * @brief	Creates a new GUI viewport element.
+		 * Creates a new GUI viewport element.
 		 *
-		 * @param	camera			Camera whos view to display in the element. Element will update the camera
-		 *							as it resizes.
-		 * @param	aspectRatio		Initial aspect of the camera. Determines how is FOV adjusted as the element resizes.
-		 * @param	fieldOfView		Initial FOV of the camera. Determines how is FOV adjusted as the element resizes.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	camera			Camera whos view to display in the element. Element will update the camera as it 
+		 *								resizes.
+		 * @param[in]	aspectRatio		Initial aspect of the camera. Determines how is FOV adjusted as the element resizes.
+		 * @param[in]	fieldOfView		Initial FOV of the camera. Determines how is FOV adjusted as the element resizes.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 *
 		 * @note Render target used by the GUIWidget and Camera must be the same. 
 		 */
 		static GUIViewport* create(const HCamera& camera, float aspectRatio, Degree fieldOfView, const String& styleName = StringUtil::BLANK);
 
 		/**
-		 * @brief	Creates a new GUI viewport element.
+		 * Creates a new GUI viewport element.
 		 *
-		 * @param	camera			Camera whos view to display in the element. Element will update the camera
-		 *							as it resizes.
-		 * @param	aspectRatio		Initial aspect of the camera. Determines how is FOV adjusted as the element resizes.
-		 * @param	fieldOfView		Initial FOV of the camera. Determines how is FOV adjusted as the element resizes.
-		 * @param	options			Options that allow you to control how is the element positioned and sized.
-		 *							This will override any similar options set by style.
-		 * @param	styleName		Optional style to use for the element. Style will be retrieved
-		 *							from GUISkin of the GUIWidget the element is used on. If not specified
-		 *							default style is used.
+		 * @param[in]	camera			Camera whos view to display in the element. Element will update the camera as it 
+		 *								resizes.
+		 * @param[in]	aspectRatio		Initial aspect of the camera. Determines how is FOV adjusted as the element resizes.
+		 * @param[in]	fieldOfView		Initial FOV of the camera. Determines how is FOV adjusted as the element resizes.
+		 * @param[in]	options			Options that allow you to control how is the element positioned and sized. This will
+		 *								override any similar options set by style.
+		 * @param[in]	styleName		Optional style to use for the element. Style will be retrieved from GUISkin of the
+		 *								GUIWidget the element is used on. If not specified default style is used.
 		 *
 		 * @note Render target used by the GUIWidget and Camera must be the same. 
 		 */
 		static GUIViewport* create(const GUIOptions& options, const HCamera& camera, 
 			float aspectRatio, Degree fieldOfView, const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIElement::_getOptimalSize
-		 */
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElement::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
 
+		/** @endcond */
+
 	protected:
 		~GUIViewport();
 
-		/**
-		 * @copydoc GUIElement::_getNumRenderElements
-		 */
+		/** @copydoc GUIElement::_getNumRenderElements */
 		virtual UINT32 _getNumRenderElements() const override;
 
-		/**
-		 * @copydoc GUIElement::_getMaterial
-		 */
+		/** @copydoc GUIElement::_getMaterial */
 		virtual const SpriteMaterialInfo& _getMaterial(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_getNumQuads
-		 */
+		/** @copydoc GUIElement::_getNumQuads */
 		virtual UINT32 _getNumQuads(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_fillBuffer
-		 */
+		/** @copydoc GUIElement::_fillBuffer */
 		virtual void _fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
 			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::updateClippedBounds
-		 */
+		/** @copydoc GUIElement::updateClippedBounds */
 		virtual void updateClippedBounds() override;
 
-		/**
-		 * @copydoc GUIElement::updateRenderElementsInternal
-		 */
+		/** @copydoc GUIElement::updateRenderElementsInternal */
 		virtual void updateRenderElementsInternal() override;
 
 	private:
 		GUIViewport(const String& styleName, const HCamera& camera, float aspectRatio, Degree fieldOfView, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIElement::_changeParentWidget
-		 */
+		/** @copydoc GUIElement::_changeParentWidget */
 		void _changeParentWidget(GUIWidget* widget) override;
 
 		HCamera mCamera;
@@ -104,4 +91,6 @@ namespace BansheeEngine
 		Degree mFieldOfView;
 		Radian mVerticalFOV;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIVirtualButtonEvent.h

@@ -7,27 +7,27 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Holds data about a GUI event that happens when a virtual button is pressed.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Holds data about a GUI event that happens when a virtual button is pressed. */
 	class BS_EXPORT GUIVirtualButtonEvent
 	{
 	public:
 		GUIVirtualButtonEvent()
 		{ }
 
-		/**
-		 * @brief	Returns the virtual button the event is referring to.
-		 */
+		/**	Returns the virtual button the event is referring to. */
 		const VirtualButton& getButton() const { return mButton; }
 	private:
 		friend class GUIManager;
 		
-		/**
-		 * @brief	Initializes the data for the event.
-		 */
+		/**	Initializes the data for the event. */
 		void setButton(const VirtualButton& button) { mButton = button; }
 
 		VirtualButton mButton;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIWidget.h

@@ -11,6 +11,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
 	 * A top level container for all types of GUI elements. Every GUI element, layout or area must be assigned to a widget
 	 * in order to be rendered.
@@ -84,6 +88,21 @@ namespace BansheeEngine
 		/**	Sets whether the widget should be rendered or not. */
 		void setIsActive(bool active);
 
+		/**	Creates a new GUI widget that will be rendered on the provided camera. */
+		static SPtr<GUIWidget> create(const CameraPtr& camera);
+
+		/**	Creates a new GUI widget that will be rendered on the provided camera. */
+		static SPtr<GUIWidget> create(const HCamera& camera);
+
+		/**	Triggered when the widget's viewport size changes. */
+		Event<void()> onOwnerTargetResized;
+
+		/**	Triggered when the parent window gained or lost focus. */
+		Event<void()> onOwnerWindowFocusChanged;
+
+	public: // ***** INTERNAL ******
+		/** @cond INTERNAL */
+
 		/** Registers a new element as a child of the widget. */
 		void _registerElement(GUIElementBase* elem);
 		
@@ -127,17 +146,8 @@ namespace BansheeEngine
 		/** Destroys the GUI widget and all child GUI elements. This is called automatically when GUIWidget is deleted. */
 		void _destroy();
 
-		/**	Creates a new GUI widget that will be rendered on the provided camera. */
-		static SPtr<GUIWidget> create(const CameraPtr& camera);
-
-		/**	Creates a new GUI widget that will be rendered on the provided camera. */
-		static SPtr<GUIWidget> create(const HCamera& camera);
+		/** @endcond */
 
-		/**	Triggered when the widget's viewport size changes. */
-		Event<void()> onOwnerTargetResized;
-
-		/**	Triggered when the parent window gained or lost focus. */
-		Event<void()> onOwnerWindowFocusChanged;
 	protected:
 		friend class SceneObject;
 		friend class GUIElementBase;
@@ -188,4 +198,6 @@ namespace BansheeEngine
 
 		HGUISkin mSkin;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsProfilerOverlay.h

@@ -10,11 +10,14 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	class ProfilerOverlayInternal;
 
-	/**
-	 * @brief	Determines type of data to display on the profiler overlay.
-	 */
+	/**	Determines type of data to display on the profiler overlay. */
 	enum class ProfilerOverlayType
 	{
 		CPUSamples,
@@ -22,37 +25,27 @@ namespace BansheeEngine
 	};
 
 	/**
-	* @brief	Handles rendering of Profiler information as an overlay in a viewport.
-	*			
-	* @note		Component wrapper of ProfilerOverlayInternal.
-	*/
+	 * Handles rendering of Profiler information as an overlay in a viewport.
+	 *			
+	 * @note	Component wrapper of ProfilerOverlayInternal.
+	 */
 	class BS_EXPORT ProfilerOverlay : public Component
 	{
 	public:
-		/**
-		 * @brief	Constructs a new overlay attached to the specified parent and displayed on the provided viewport.
-		 */
+		/**	Constructs a new overlay attached to the specified parent and displayed on the provided viewport. */
 		ProfilerOverlay(const HSceneObject& parent, const CameraPtr& target);
 		~ProfilerOverlay();
 
-		/**
-		 * @brief	Changes the camera to display the overlay on.
-		 */
+		/**	Changes the camera to display the overlay on. */
 		void setTarget(const CameraPtr& target);
 
-		/**
-		 * @brief	Shows the overlay of the specified type.
-		 */
+		/**	Shows the overlay of the specified type. */
 		void show(ProfilerOverlayType type);
 
-		/**
-		 * @brief	Hides the overlay.
-		 */
+		/**	Hides the overlay. */
 		void hide();
 
-		/**
-		 * @copydoc	Component::update
-		 */
+		/** @copydoc Component::update */
 		void update() override;
 
 	private:
@@ -64,20 +57,16 @@ namespace BansheeEngine
 	public:
 		friend class ProfilerOverlayRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const override;
+		RTTITypeBase* getRTTI() const override;
 
 		ProfilerOverlay() { } // Serialization only
 	};
 
-	/**
-	 * @brief	Handles rendering of Profiler information as an overlay in a viewport.
-	 */
+	/**	Handles rendering of Profiler information as an overlay in a viewport. */
 	class BS_EXPORT ProfilerOverlayInternal
 	{
 	public:
-		/**
-		 * @brief	Holds data about GUI elements in a single row of a "CPU basic" sample.
-		 */
+		/**	Holds data about GUI elements in a single row of a "CPU basic" sample. */
 		struct BasicRow
 		{
 			GUILayout* labelLayout;
@@ -107,9 +96,7 @@ namespace BansheeEngine
 			bool disabled;
 		};
 
-		/**
-		 * @brief	Holds data about GUI elements in a single row of a "CPU precise" sample.
-		 */
+		/**	Holds data about GUI elements in a single row of a "CPU precise" sample. */
 		struct PreciseRow
 		{
 			GUILayout* labelLayout;
@@ -139,9 +126,7 @@ namespace BansheeEngine
 			bool disabled;
 		};
 		
-		/**
-		 * @brief	Holds data about GUI elements in a single row of a GPU sample.
-		 */
+		/**	Holds data about GUI elements in a single row of a GPU sample. */
 		struct GPUSampleRow
 		{
 			GUILayout* layout;
@@ -156,58 +141,40 @@ namespace BansheeEngine
 		};
 
 	public:
-		/**
-		 * @brief	Constructs a new overlay attached to the specified parent and displayed on the provided camera.
-		 */
+		/**	Constructs a new overlay attached to the specified parent and displayed on the provided camera. */
 		ProfilerOverlayInternal(const CameraPtr& target);
 		~ProfilerOverlayInternal();
 
-		/**
-		 * @brief	Changes the camera to display the overlay on.
-		 */
+		/**	Changes the camera to display the overlay on. */
 		void setTarget(const CameraPtr& target);
 
-		/**
-		 * @brief	Shows the overlay of the specified type.
-		 */
+		/**	Shows the overlay of the specified type. */
 		void show(ProfilerOverlayType type);
 
-		/**
-		 * @brief	Hides the overlay.
-		 */
+		/**	Hides the overlay. */
 		void hide();
 
-		/**
-		 * @brief	Updates overlay contents. Should be called once per frame.
-		 */
+		/**	Updates overlay contents. Should be called once per frame. */
 		void update();
 	private:
-		/**
-		 * @brief	Called whenever the viewport resizes in order to rearrange the GUI elements.
-		 */
+		/**	Called whenever the viewport resizes in order to rearrange the GUI elements. */
 		void targetResized();
 
-		/**
-		 * @brief	Updates sizes of GUI areas used for displaying CPU sample data. To be called
-		 *			after viewport change or resize.
-		 */
+		/** Updates sizes of GUI areas used for displaying CPU sample data. To be called after viewport change or resize. */
 		void updateCPUSampleAreaSizes();
 
-		/**
-		 * @brief	Updates sizes of GUI areas used for displaying GPU sample data. To be called
-		 *			after viewport change or resize.
-		 */
+		/** Updates sizes of GUI areas used for displaying GPU sample data. To be called after viewport change or resize. */
 		void updateGPUSampleAreaSizes();
 
 		/**
-		 * @brief	Updates CPU GUI elements from the data in the provided profiler reports. To be called
-		 *			whenever a new report is received.
+		 * Updates CPU GUI elements from the data in the provided profiler reports. To be called whenever a new report is 
+		 * received.
 		 */
 		void updateCPUSampleContents(const ProfilerReport& simReport, const ProfilerReport& coreReport);
 
 		/**
-		 * @brief	Updates GPU GUI elemnts from the data in the provided profiler report. To be called whenever
-		 *			a new report is received.
+		 * Updates GPU GUI elemnts from the data in the provided profiler report. To be called whenever a new report is
+		 * received.
 		 */
 		void updateGPUSampleContents(const GPUProfilerReport& gpuReport);
 
@@ -305,4 +272,7 @@ namespace BansheeEngine
 		HEvent mTargetResizedConn;
 		bool mIsShown;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsShortcutKey.h

@@ -7,10 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	A key combination that is used for triggering keyboard shortcuts.
-	 *			Contains a button code and an optional modifier.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** A key combination that is used for triggering keyboard shortcuts. Contains a button code and an optional modifier. */
 	struct BS_EXPORT ShortcutKey
 	{
 		struct BS_EXPORT Hash
@@ -26,14 +28,10 @@ namespace BansheeEngine
 		ShortcutKey();
 		ShortcutKey(ButtonModifier modifier, ButtonCode code);
 
-		/**
-		 * @brief	Checks is the shortcut button and modifier combination valid.
-		 */
+		/**	Checks is the shortcut button and modifier combination valid. */
 		bool isValid() const { return button != BC_UNASSIGNED; }
 
-		/**
-		 * @brief	Returns a readable name of the shortcut key (e.g. "Shift + F").
-		 */
+		/**	Returns a readable name of the shortcut key (e.g. "Shift + F"). */
 		WString getName() const;
 
 		ButtonModifier modifier;
@@ -41,4 +39,7 @@ namespace BansheeEngine
 
 		static const ShortcutKey NONE;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsShortcutManager.h

@@ -8,9 +8,14 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Allows you to register global keyboard shortcuts that trigger
-	 *			callbacks when a certain key, or a key combination is pressed.
+	 * Allows you to register global keyboard shortcuts that trigger callbacks when a certain key, or a key combination is
+	 * pressed.
 	 */
 	class BS_EXPORT ShortcutManager : public Module<ShortcutManager>
 	{
@@ -18,24 +23,20 @@ namespace BansheeEngine
 		ShortcutManager();
 		~ShortcutManager();
 
-		/**
-		 * @brief	Registers a new shortcut key and a callback to be called when the shortcut key is triggered.
-		 */
+		/**	Registers a new shortcut key and a callback to be called when the shortcut key is triggered. */
 		void addShortcut(const ShortcutKey& key, std::function<void()> callback);
 
-		/**
-		 * @brief	Removes an existing shortcut key (it's callback will no longer be triggered when this
-		 *			combination is pressed).
-		 */
+		/** Removes an existing shortcut key (it's callback will no longer be triggered when this combination is pressed). */
 		void removeShortcut(const ShortcutKey& key);
 
 	private:
-		/**
-		 * @brief	Triggered whenever a user presses a button.
-		 */
+		/**	Triggered whenever a user presses a button. */
 		void onButtonDown(const ButtonEvent& event);
 
 		UnorderedMap<ShortcutKey, std::function<void()>, ShortcutKey::Hash, ShortcutKey::Equals> mShortcuts;
 		HEvent mOnButtonDownConn;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeUtility/Include/BsAsyncOp.h

@@ -91,6 +91,7 @@ namespace BansheeEngine
 			return any_cast<T>(mData->mReturnValue);
 		}
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**

BansheeUtility/Include/BsDebug.h

@@ -67,6 +67,7 @@ namespace BansheeEngine
 		 */
 		Event<void()> onLogModified;
 
+	public: // ***** INTERNAL ******
 		/** @cond INTERNAL */
 
 		/**