More work on improving documentation for Doxygen generation

BansheeEngine/Include/BsCCamera.h

@@ -1,350 +1,239 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsCamera.h"
-#include "BsComponent.h"
-#include "BsViewport.h"
-
-namespace BansheeEngine 
-{
-	/**
-	 * @copydoc	Camera
-	 * 			
-	 * Wraps a Camera as a Component.
-	 */
-    class BS_EXPORT CCamera : public Component
-    {
-    public:
-		CCamera(const HSceneObject& parent, RenderTargetPtr target = nullptr,
-			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
-
-        virtual ~CCamera();
-
-		/**
-		 * @copydoc	Camera::getViewport
-		 */
-		ViewportPtr getViewport() const { return mInternal->getViewport(); }
-
-		/**
-		 * @copydoc	Camera::setHorzFOV
-		 */
-		virtual void setHorzFOV(const Radian& fovy) { mInternal->setHorzFOV(fovy); }
-
-		/**
-		 * @copydoc	Camera::getHorzFOV
-		 */
-		virtual const Radian& getHorzFOV() const { return mInternal->getHorzFOV(); }
-
-		/**
-		 * @copydoc	Camera::setNearClipDistance
-		 */
-		virtual void setNearClipDistance(float nearDist) { mInternal->setNearClipDistance(nearDist); }
-
-		/**
-		 * @copydoc	Camera::getNearClipDistance
-		 */
-		virtual float getNearClipDistance() const { return mInternal->getNearClipDistance(); }
-
-		/**
-		 * @copydoc	Camera::setFarClipDistance
-		 */
-		virtual void setFarClipDistance(float farDist) { mInternal->setFarClipDistance(farDist); }
-
-		/**
-		 * @copydoc	Camera::getFarClipDistance
-		 */
-		virtual float getFarClipDistance() const { return mInternal->getFarClipDistance(); }
-
-		/**
-		 * @copydoc	Camera::setAspectRatio
-		 */
-		virtual void setAspectRatio(float ratio) { mInternal->setAspectRatio(ratio); }
-
-		/**
-		 * @copydoc	Camera::getAspectRatio
-		 */
-		virtual float getAspectRatio() const { return mInternal->getAspectRatio(); }
-
-		/**
-		 * @copydoc	Camera::setFrustumExtents
-		 */
-		virtual void setFrustumExtents(float left, float right, float top, float bottom)
-		{
-			mInternal->setFrustumExtents(left, right, top, bottom);
-		}
-
-		/**
-		 * @copydoc	Camera::resetFrustumExtents
-		 */
-		virtual void resetFrustumExtents() { mInternal->resetFrustumExtents(); }
-
-		/**
-		 * @copydoc	Camera::getFrustumExtents
-		 */
-		virtual void getFrustumExtents(float& outleft, float& outright, float& outtop, float& outbottom) const
-		{
-			mInternal->getFrustumExtents(outleft, outright, outtop, outbottom);
-		}
-
-		/**
-		 * @copydoc	Camera::getProjectionMatrixRS
-		 */
-		virtual const Matrix4& getProjectionMatrixRS() const { return mInternal->getProjectionMatrixRS(); }
-
-		/**
-		 * @copydoc	Camera::getProjectionMatrix
-		 */
-		virtual const Matrix4& getProjectionMatrix() const { return mInternal->getProjectionMatrix(); }
-
-		/**
-		 * @copydoc	Camera::getViewMatrix
-		 */
-		virtual const Matrix4& getViewMatrix() const { updateView(); return mInternal->getViewMatrix(); }
-
-		/**
-		 * @copydoc	Camera::setCustomViewMatrix
-		 */
-		virtual void setCustomViewMatrix(bool enable, const Matrix4& viewMatrix = Matrix4::IDENTITY)
-		{
-			mInternal->setCustomViewMatrix(enable, viewMatrix);
-		}
-
-		/**
-		 * @copydoc	Camera::isCustomViewMatrixEnabled
-		 */
-		virtual bool isCustomViewMatrixEnabled() const { return mInternal->isCustomViewMatrixEnabled(); }
-		
-		/**
-		 * @copydoc	Camera::setCustomProjectionMatrix
-		 */
-		virtual void setCustomProjectionMatrix(bool enable, const Matrix4& projectionMatrix = Matrix4::IDENTITY)
-		{
-			mInternal->setCustomProjectionMatrix(enable, projectionMatrix);
-		}
-
-		/**
-		 * @copydoc	Camera::isCustomProjectionMatrixEnabled
-		 */
-		virtual bool isCustomProjectionMatrixEnabled() const { return mInternal->isCustomProjectionMatrixEnabled(); }
-
-		/**
-		 * @copydoc	Camera::getFrustum
-		 */
-		virtual const ConvexVolume& getFrustum() const { return mInternal->getFrustum(); }
-
-		/**
-		 * @copydoc	Camera::getWorldFrustum
-		 */
-        virtual ConvexVolume getWorldFrustum() const;
-
-		/**
-		 * @copydoc	Camera::getBoundingBox
-		 */
-		const AABox& getBoundingBox() const { return mInternal->getBoundingBox(); }
-
-		/**
-		 * @copydoc	Camera::setProjectionType
-		 */
-		virtual void setProjectionType(ProjectionType pt) { mInternal->setProjectionType(pt); }
-
-		/**
-		 * @copydoc	Camera::getProjectionType
-		 */
-		virtual ProjectionType getProjectionType() const { return mInternal->getProjectionType(); }
-
-		/**
-		 * @copydoc	Camera::setOrthoWindow
-		 */
-		virtual void setOrthoWindow(float w, float h) { mInternal->setOrthoWindow(w, h); }
-
-		/**
-		 * @copydoc	Camera::setOrthoWindowHeight
-		 */
-		virtual void setOrthoWindowHeight(float h) { mInternal->setOrthoWindowHeight(h); }
-
-		/**
-		 * @copydoc	Camera::setOrthoWindowWidth
-		 */
-		virtual void setOrthoWindowWidth(float w) { mInternal->setOrthoWindowWidth(w); }
-
-		/**
-		 * @copydoc	Camera::getOrthoWindowHeight
-		 */
-		virtual float getOrthoWindowHeight() const { return mInternal->getOrthoWindowHeight(); }
-
-		/**
-		 * @copydoc	Camera::getOrthoWindowWidth
-		 */
-		virtual float getOrthoWindowWidth() const { return mInternal->getOrthoWindowWidth(); }
-
-		/**
-		 * @copydoc	Camera::getPriority
-		 */
-		INT32 getPriority() const { return mInternal->getPriority(); }
-
-		/**
-		 * @copydoc	Camera::setPriority
-		 */
-		void setPriority(INT32 priority) { mInternal->setPriority(priority); }
-
-		/**
-		 * @copydoc	Camera::getLayers
-		 */
-		UINT64 getLayers() const { return mInternal->getLayers(); }
-
-		/**
-		 * @copydoc	Camera::setLayers
-		 */
-		void setLayers(UINT64 layers) { mInternal->setLayers(layers); }
-
-		/**
-		 * @copydoc	Camera::getFlags
-		 */
-		CameraFlags getFlags() const { return mInternal->getFlags(); }
-
-		/**
-		 * @copydoc	Camera::setFlags
-		 */
-		void setFlags(const CameraFlags& flags) { mInternal->setFlags(flags); }
-
-		/**
-		 * @copydoc	Camera::worldToScreenPoint
-		 */
-		Vector2I worldToScreenPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToScreenPoint(worldPoint); }
-
-		/**
-		 * @copydoc	Camera::worldToClipPoint
-		 */
-		Vector2 worldToClipPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToClipPoint(worldPoint); }
-
-		/**
-		 * @copydoc	Camera::worldToViewPoint
-		 */
-		Vector3 worldToViewPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToViewPoint(worldPoint); }
-
-		/**
-		 * @copydoc	Camera::screenToWorldPoint
-		 */
-		Vector3 screenToWorldPoint(const Vector2I& screenPoint, float depth = 0.5f) const { updateView(); return mInternal->screenToWorldPoint(screenPoint, depth); }
-
-		/**
-		 * @copydoc	Camera::screenToViewPoint
-		 */
-		Vector3 screenToViewPoint(const Vector2I& screenPoint, float depth = 0.5f) const { return mInternal->screenToViewPoint(screenPoint, depth); }
-
-		/**
-		 * @copydoc	Camera::screenToClipPoint
-		 */
-		Vector2 screenToClipPoint(const Vector2I& screenPoint) const { return mInternal->screenToClipPoint(screenPoint); }
-
-		/**
-		 * @copydoc	Camera::viewToWorldPoint
-		 */
-		Vector3 viewToWorldPoint(const Vector3& viewPoint) const { updateView(); return mInternal->viewToWorldPoint(viewPoint); }
-
-		/**
-		 * @copydoc	Camera::viewToScreenPoint
-		 */
-		Vector2I viewToScreenPoint(const Vector3& viewPoint) const { return mInternal->viewToScreenPoint(viewPoint); }
-
-		/**
-		 * @copydoc	Camera::viewToClipPoint
-		 */
-		Vector2 viewToClipPoint(const Vector3& viewPoint) const { return mInternal->viewToClipPoint(viewPoint); }
-
-		/**
-		 * @copydoc	Camera::clipToWorldPoint
-		 */
-		Vector3 clipToWorldPoint(const Vector2& clipPoint, float depth = 0.5f) const { updateView(); return mInternal->clipToWorldPoint(clipPoint, depth); }
-
-		/**
-		 * @copydoc	Camera::clipToViewPoint
-		 */
-		Vector3 clipToViewPoint(const Vector2& clipPoint, float depth = 0.5f) const { return mInternal->clipToViewPoint(clipPoint, depth); }
-
-		/**
-		 * @copydoc	Camera::clipToScreenPoint
-		 */
-		Vector2I clipToScreenPoint(const Vector2& clipPoint) const { return mInternal->clipToScreenPoint(clipPoint); }
-
-		/**
-		 * @copydoc	Camera::screenPointToRay
-		 */
-		Ray screenPointToRay(const Vector2I& screenPoint) const { updateView(); return mInternal->screenPointToRay(screenPoint); }
-
-		/**
-		 * @copydoc	Camera::projectPoint
-		 */
-		Vector3 projectPoint(const Vector3& point) const { return mInternal->projectPoint(point); }
-
-		/**
-		 * @copydoc	Camera::unprojectPoint
-		 */
-		Vector3 unprojectPoint(const Vector3& point) const { return mInternal->unprojectPoint(point); }
-
-		/**
-		 * @copydoc	Camera::isMain
-		 */	
-		bool isMain() const { return mInternal->isMain(); }
-
-		/**
-		 * @copydoc	Camera::setMain
-		 */	
-		void setMain(bool main);
-
-		/**
-		 * @brief	Returns the internal camera that is used for
-		 *			majority of operations by this component.
-		 */
-		CameraPtr _getCamera() const { updateView(); return mInternal; }
-
-    protected:
-		/**
-		 * @brief	Checks if the world transform of the camera changed, and if needed updates
-		 *			the view matrix.
-		 */
-		void updateView() const;
-
-		mutable CameraPtr mInternal;
-
-		// Only valid during construction
-		RenderTargetPtr mTarget;
-		float mLeft;
-		float mTop;
-		float mWidth;
-		float mHeight;
-
-		/************************************************************************/
-		/* 						COMPONENT OVERRIDES                      		*/
-		/************************************************************************/
-	protected:
-		friend class SceneObject;
-
-		/**
-		 * @copydoc	Component::onInitialized
-		 */
-		void onInitialized() override;
-
-		/**
-		 * @copydoc	Component::onDestroyed
-		 */
-		void onDestroyed() override;
-
-	public:
-		/**
-		 * @copydoc	Component::update
-		 */
-		virtual void update() override;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class CCameraRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const override;
-
-	protected:
-		CCamera() {} // Serialization only
-     };
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsCamera.h"
+#include "BsComponent.h"
+
+namespace BansheeEngine 
+{
+	/** @addtogroup Components
+	 *  @{
+	 */
+
+	/**
+	 * @copydoc	Camera
+	 * 			
+	 * Wraps a Camera as a Component.
+	 */
+    class BS_EXPORT CCamera : public Component
+    {
+    public:
+		CCamera(const HSceneObject& parent, RenderTargetPtr target = nullptr,
+			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
+
+        virtual ~CCamera();
+
+		/** @copydoc Camera::getViewport */
+		ViewportPtr getViewport() const { return mInternal->getViewport(); }
+
+		/** @copydoc Camera::setHorzFOV */
+		virtual void setHorzFOV(const Radian& fovy) { mInternal->setHorzFOV(fovy); }
+
+		/** @copydoc Camera::getHorzFOV */
+		virtual const Radian& getHorzFOV() const { return mInternal->getHorzFOV(); }
+
+		/** @copydoc Camera::setNearClipDistance */
+		virtual void setNearClipDistance(float nearDist) { mInternal->setNearClipDistance(nearDist); }
+
+		/** @copydoc Camera::getNearClipDistance */
+		virtual float getNearClipDistance() const { return mInternal->getNearClipDistance(); }
+
+		/** @copydoc Camera::setFarClipDistance */
+		virtual void setFarClipDistance(float farDist) { mInternal->setFarClipDistance(farDist); }
+
+		/** @copydoc Camera::getFarClipDistance */
+		virtual float getFarClipDistance() const { return mInternal->getFarClipDistance(); }
+
+		/** @copydoc Camera::setAspectRatio */
+		virtual void setAspectRatio(float ratio) { mInternal->setAspectRatio(ratio); }
+
+		/** @copydoc Camera::getAspectRatio */
+		virtual float getAspectRatio() const { return mInternal->getAspectRatio(); }
+
+		/** @copydoc Camera::setFrustumExtents */
+		virtual void setFrustumExtents(float left, float right, float top, float bottom)
+		{
+			mInternal->setFrustumExtents(left, right, top, bottom);
+		}
+
+		/** @copydoc Camera::resetFrustumExtents */
+		virtual void resetFrustumExtents() { mInternal->resetFrustumExtents(); }
+
+		/** @copydoc Camera::getFrustumExtents */
+		virtual void getFrustumExtents(float& outleft, float& outright, float& outtop, float& outbottom) const
+		{
+			mInternal->getFrustumExtents(outleft, outright, outtop, outbottom);
+		}
+
+		/** @copydoc Camera::getProjectionMatrixRS */
+		virtual const Matrix4& getProjectionMatrixRS() const { return mInternal->getProjectionMatrixRS(); }
+
+		/** @copydoc Camera::getProjectionMatrix */
+		virtual const Matrix4& getProjectionMatrix() const { return mInternal->getProjectionMatrix(); }
+
+		/** @copydoc Camera::getViewMatrix */
+		virtual const Matrix4& getViewMatrix() const { updateView(); return mInternal->getViewMatrix(); }
+
+		/** @copydoc Camera::setCustomViewMatrix */
+		virtual void setCustomViewMatrix(bool enable, const Matrix4& viewMatrix = Matrix4::IDENTITY)
+		{
+			mInternal->setCustomViewMatrix(enable, viewMatrix);
+		}
+
+		/** @copydoc Camera::isCustomViewMatrixEnabled */
+		virtual bool isCustomViewMatrixEnabled() const { return mInternal->isCustomViewMatrixEnabled(); }
+		
+		/** @copydoc Camera::setCustomProjectionMatrix */
+		virtual void setCustomProjectionMatrix(bool enable, const Matrix4& projectionMatrix = Matrix4::IDENTITY)
+		{
+			mInternal->setCustomProjectionMatrix(enable, projectionMatrix);
+		}
+
+		/** @copydoc Camera::isCustomProjectionMatrixEnabled */
+		virtual bool isCustomProjectionMatrixEnabled() const { return mInternal->isCustomProjectionMatrixEnabled(); }
+
+		/** @copydoc Camera::getFrustum */
+		virtual const ConvexVolume& getFrustum() const { return mInternal->getFrustum(); }
+
+		/** @copydoc Camera::getWorldFrustum */
+        virtual ConvexVolume getWorldFrustum() const;
+
+		/** @copydoc Camera::getBoundingBox */
+		const AABox& getBoundingBox() const { return mInternal->getBoundingBox(); }
+
+		/** @copydoc Camera::setProjectionType */
+		virtual void setProjectionType(ProjectionType pt) { mInternal->setProjectionType(pt); }
+
+		/** @copydoc Camera::getProjectionType */
+		virtual ProjectionType getProjectionType() const { return mInternal->getProjectionType(); }
+
+		/** @copydoc Camera::setOrthoWindow */
+		virtual void setOrthoWindow(float w, float h) { mInternal->setOrthoWindow(w, h); }
+
+		/** @copydoc Camera::setOrthoWindowHeight */
+		virtual void setOrthoWindowHeight(float h) { mInternal->setOrthoWindowHeight(h); }
+
+		/** @copydoc Camera::setOrthoWindowWidth */
+		virtual void setOrthoWindowWidth(float w) { mInternal->setOrthoWindowWidth(w); }
+
+		/** @copydoc Camera::getOrthoWindowHeight */
+		virtual float getOrthoWindowHeight() const { return mInternal->getOrthoWindowHeight(); }
+
+		/** @copydoc Camera::getOrthoWindowWidth */
+		virtual float getOrthoWindowWidth() const { return mInternal->getOrthoWindowWidth(); }
+
+		/** @copydoc Camera::getPriority */
+		INT32 getPriority() const { return mInternal->getPriority(); }
+
+		/** @copydoc Camera::setPriority */
+		void setPriority(INT32 priority) { mInternal->setPriority(priority); }
+
+		/** @copydoc Camera::getLayers */
+		UINT64 getLayers() const { return mInternal->getLayers(); }
+
+		/** @copydoc Camera::setLayers */
+		void setLayers(UINT64 layers) { mInternal->setLayers(layers); }
+
+		/** @copydoc Camera::getFlags */
+		CameraFlags getFlags() const { return mInternal->getFlags(); }
+
+		/** @copydoc Camera::setFlags */
+		void setFlags(const CameraFlags& flags) { mInternal->setFlags(flags); }
+
+		/** @copydoc Camera::worldToScreenPoint */
+		Vector2I worldToScreenPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToScreenPoint(worldPoint); }
+
+		/** @copydoc Camera::worldToClipPoint */
+		Vector2 worldToClipPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToClipPoint(worldPoint); }
+
+		/** @copydoc Camera::worldToViewPoint */
+		Vector3 worldToViewPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToViewPoint(worldPoint); }
+
+		/** @copydoc Camera::screenToWorldPoint */
+		Vector3 screenToWorldPoint(const Vector2I& screenPoint, float depth = 0.5f) const { updateView(); return mInternal->screenToWorldPoint(screenPoint, depth); }
+
+		/** @copydoc Camera::screenToViewPoint */
+		Vector3 screenToViewPoint(const Vector2I& screenPoint, float depth = 0.5f) const { return mInternal->screenToViewPoint(screenPoint, depth); }
+
+		/** @copydoc Camera::screenToClipPoint */
+		Vector2 screenToClipPoint(const Vector2I& screenPoint) const { return mInternal->screenToClipPoint(screenPoint); }
+
+		/** @copydoc Camera::viewToWorldPoint */
+		Vector3 viewToWorldPoint(const Vector3& viewPoint) const { updateView(); return mInternal->viewToWorldPoint(viewPoint); }
+
+		/** @copydoc Camera::viewToScreenPoint */
+		Vector2I viewToScreenPoint(const Vector3& viewPoint) const { return mInternal->viewToScreenPoint(viewPoint); }
+
+		/** @copydoc Camera::viewToClipPoint */
+		Vector2 viewToClipPoint(const Vector3& viewPoint) const { return mInternal->viewToClipPoint(viewPoint); }
+
+		/** @copydoc Camera::clipToWorldPoint */
+		Vector3 clipToWorldPoint(const Vector2& clipPoint, float depth = 0.5f) const { updateView(); return mInternal->clipToWorldPoint(clipPoint, depth); }
+
+		/** @copydoc Camera::clipToViewPoint */
+		Vector3 clipToViewPoint(const Vector2& clipPoint, float depth = 0.5f) const { return mInternal->clipToViewPoint(clipPoint, depth); }
+
+		/** @copydoc Camera::clipToScreenPoint */
+		Vector2I clipToScreenPoint(const Vector2& clipPoint) const { return mInternal->clipToScreenPoint(clipPoint); }
+
+		/** @copydoc Camera::screenPointToRay */
+		Ray screenPointToRay(const Vector2I& screenPoint) const { updateView(); return mInternal->screenPointToRay(screenPoint); }
+
+		/** @copydoc Camera::projectPoint */
+		Vector3 projectPoint(const Vector3& point) const { return mInternal->projectPoint(point); }
+
+		/** @copydoc Camera::unprojectPoint */
+		Vector3 unprojectPoint(const Vector3& point) const { return mInternal->unprojectPoint(point); }
+
+		/** @copydoc Camera::isMain */	
+		bool isMain() const { return mInternal->isMain(); }
+
+		/** @copydoc Camera::setMain */	
+		void setMain(bool main);
+
+		/** Returns the internal camera that is used for majority of operations by this component. */
+		CameraPtr _getCamera() const { updateView(); return mInternal; }
+
+    protected:
+		/** Checks if the world transform of the camera changed, and if needed updates the view matrix. */
+		void updateView() const;
+
+		mutable CameraPtr mInternal;
+
+		// Only valid during construction
+		RenderTargetPtr mTarget;
+		float mLeft;
+		float mTop;
+		float mWidth;
+		float mHeight;
+
+		/************************************************************************/
+		/* 						COMPONENT OVERRIDES                      		*/
+		/************************************************************************/
+	protected:
+		friend class SceneObject;
+
+		/** @copydoc Component::onInitialized */
+		void onInitialized() override;
+
+		/** @copydoc Component::onDestroyed */
+		void onDestroyed() override;
+
+	public:
+		/** @copydoc Component::update */
+		virtual void update() override;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class CCameraRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const override;
+
+	protected:
+		CCamera() {} // Serialization only
+     };
+
+	 /** @} */
 }

BansheeEngine/Include/BsCGUIWidget.h

@@ -7,6 +7,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/** Component wrapper for GUIWidget. */
 	class BS_EXPORT CGUIWidget : public Component
 	{
@@ -101,4 +105,6 @@ namespace BansheeEngine
 
 		CGUIWidget() { } // Serialization only
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsCLight.h

@@ -1,121 +1,127 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsLight.h"
-#include "BsComponent.h"
-
-namespace BansheeEngine 
-{
-	/**
-	 * @copydoc	LightInternal
-	 *
-	 * Wraps Light as a Component.
-	 */
-    class BS_EXPORT CLight : public Component
-    {
-    public:
-		CLight(const HSceneObject& parent, LightType type = LightType::Point, Color color = Color::White, 
-			float intensity = 100.0f, float range = 1.0f, bool castsShadows = false, Degree spotAngle = Degree(45), 
-			Degree spotFalloffAngle = Degree(40));
-
-		virtual ~CLight();
-
-	    /** @copydoc LightInternal::getPosition */
-		Vector3 getPosition() const { return mInternal->getPosition(); }
-
-	    /** @copydoc LightInternal::setPosition */
-		void setPosition(const Vector3& position) { mInternal->setPosition(position); }
-
-	    /** @copydoc LightInternal::getRotation */
-		Quaternion getRotation() const { return mInternal->getRotation(); }
-
-	    /** @copydoc LightInternal::setRotation */
-		void setRotation(const Quaternion& rotation) { mInternal->setRotation(rotation); }
-
-	    /** @copydoc LightInternal::getType */
-		LightType getType() const { return mInternal->getType(); }
-
-	    /** @copydoc LightInternal::setType */
-		void setType(LightType type) { mInternal->setType(type); }
-
-	    /** @copydoc LightInternal::getCastsShadow */
-		bool getCastsShadow() const { return mInternal->getCastsShadow(); }
-
-	    /** @copydoc LightInternal::setCastsShadow  */
-		void setCastsShadow(bool castsShadow) { mInternal->setCastsShadow(castsShadow); }
-
-	    /** @copydoc LightInternal::getColor */
-		Color getColor() const { return mInternal->getColor(); }
-
-	    /** @copydoc LightInternal::setColor */
-		void setColor(const Color& color) { mInternal->setColor(color); }
-
-	    /** @copydoc LightInternal::getRange */
-		float getRange() const { return mInternal->getRange(); }
-
-	    /** @copydoc LightInternal::setRange */
-		void setRange(float range) { mInternal->setRange(range);; }
-
-	    /** @copydoc LightInternal::getIntensity */
-		float getIntensity() const { return mInternal->getIntensity(); }
-
-	    /** @copydoc LightInternal::setIntensity */
-		void setIntensity(float intensity) { mInternal->setIntensity(intensity); }
-
-	    /** @copydoc LightInternal::getSpotAngle */
-		Degree getSpotAngle() const { return mInternal->getSpotAngle(); }
-
-	    /** @copydoc LightInternal::setSpotAngle */
-		void setSpotAngle(const Degree& spotAngle) { mInternal->setSpotAngle(spotAngle); }
-
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsLight.h"
+#include "BsComponent.h"
+
+namespace BansheeEngine 
+{
+	/** @addtogroup Components
+	 *  @{
+	 */
+
+	/**
+	 * @copydoc	Light
+	 *
+	 * Wraps Light as a Component.
+	 */
+    class BS_EXPORT CLight : public Component
+    {
+    public:
+		CLight(const HSceneObject& parent, LightType type = LightType::Point, Color color = Color::White, 
+			float intensity = 100.0f, float range = 1.0f, bool castsShadows = false, Degree spotAngle = Degree(45), 
+			Degree spotFalloffAngle = Degree(40));
+
+		virtual ~CLight();
+
+	    /** @copydoc LightInternal::getPosition */
+		Vector3 getPosition() const { return mInternal->getPosition(); }
+
+	    /** @copydoc LightInternal::setPosition */
+		void setPosition(const Vector3& position) { mInternal->setPosition(position); }
+
+	    /** @copydoc LightInternal::getRotation */
+		Quaternion getRotation() const { return mInternal->getRotation(); }
+
+	    /** @copydoc LightInternal::setRotation */
+		void setRotation(const Quaternion& rotation) { mInternal->setRotation(rotation); }
+
+	    /** @copydoc LightInternal::getType */
+		LightType getType() const { return mInternal->getType(); }
+
+	    /** @copydoc LightInternal::setType */
+		void setType(LightType type) { mInternal->setType(type); }
+
+	    /** @copydoc LightInternal::getCastsShadow */
+		bool getCastsShadow() const { return mInternal->getCastsShadow(); }
+
+	    /** @copydoc LightInternal::setCastsShadow  */
+		void setCastsShadow(bool castsShadow) { mInternal->setCastsShadow(castsShadow); }
+
+	    /** @copydoc LightInternal::getColor */
+		Color getColor() const { return mInternal->getColor(); }
+
+	    /** @copydoc LightInternal::setColor */
+		void setColor(const Color& color) { mInternal->setColor(color); }
+
+	    /** @copydoc LightInternal::getRange */
+		float getRange() const { return mInternal->getRange(); }
+
+	    /** @copydoc LightInternal::setRange */
+		void setRange(float range) { mInternal->setRange(range);; }
+
+	    /** @copydoc LightInternal::getIntensity */
+		float getIntensity() const { return mInternal->getIntensity(); }
+
+	    /** @copydoc LightInternal::setIntensity */
+		void setIntensity(float intensity) { mInternal->setIntensity(intensity); }
+
+	    /** @copydoc LightInternal::getSpotAngle */
+		Degree getSpotAngle() const { return mInternal->getSpotAngle(); }
+
+	    /** @copydoc LightInternal::setSpotAngle */
+		void setSpotAngle(const Degree& spotAngle) { mInternal->setSpotAngle(spotAngle); }
+
 		/** @copydoc LightInternal::getPhysicallyBasedAttenuation  */
 		bool getPhysicallyBasedAttenuation() const { return mInternal->getPhysicallyBasedAttenuation(); }
 
 		/**  @copydoc LightInternal::setPhysicallyBasedAttenuation  */
-		void setPhysicallyBasedAttenuation(bool enabled) { mInternal->setPhysicallyBasedAttenuation(enabled); }
-
-	    /** @copydoc LightInternal::getBounds  */
-		Sphere getBounds() const;
-
-	    /**	Returns the light that this component wraps. */
-		SPtr<Light> _getLight() const { return mInternal; }
-
-    protected:
-		mutable SPtr<Light> mInternal;
-
-		// Only valid during construction
-		LightType mType;
-		Color mColor;
-		float mIntensity; 
-		float mRange; 
-		bool mCastsShadows; 
-		Degree mSpotAngle; 
-		Degree mSpotFalloffAngle;
-
-		/************************************************************************/
-		/* 						COMPONENT OVERRIDES                      		*/
-		/************************************************************************/
-	protected:
-		friend class SceneObject;
-
-	    /** @copydoc Component::onInitialized */
-		void onInitialized() override;
-
-	    /** @copydoc Component::onDestroyed */
-		void onDestroyed() override;
-
-		/** @copydoc Component::update */
-		void update() override { }
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class CLightRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		RTTITypeBase* getRTTI() const override;
-
-	protected:
-		CLight() {} // Serialization only
-     };
+		void setPhysicallyBasedAttenuation(bool enabled) { mInternal->setPhysicallyBasedAttenuation(enabled); }
+
+	    /** @copydoc LightInternal::getBounds  */
+		Sphere getBounds() const;
+
+	    /**	Returns the light that this component wraps. */
+		SPtr<Light> _getLight() const { return mInternal; }
+
+    protected:
+		mutable SPtr<Light> mInternal;
+
+		// Only valid during construction
+		LightType mType;
+		Color mColor;
+		float mIntensity; 
+		float mRange; 
+		bool mCastsShadows; 
+		Degree mSpotAngle; 
+		Degree mSpotFalloffAngle;
+
+		/************************************************************************/
+		/* 						COMPONENT OVERRIDES                      		*/
+		/************************************************************************/
+	protected:
+		friend class SceneObject;
+
+	    /** @copydoc Component::onInitialized */
+		void onInitialized() override;
+
+	    /** @copydoc Component::onDestroyed */
+		void onDestroyed() override;
+
+		/** @copydoc Component::update */
+		void update() override { }
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class CLightRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		RTTITypeBase* getRTTI() const override;
+
+	protected:
+		CLight() {} // Serialization only
+     };
+
+	 /** @} */
 }

BansheeEngine/Include/BsCRenderable.h

@@ -1,113 +1,90 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsRenderable.h"
-#include "BsBounds.h"
-#include "BsComponent.h"
-
-namespace BansheeEngine
-{
-	/**
-	 * @copydoc	Renderable
-	 * 			
-	 * Wraps a Renderable as a Component.
-	 */
-	class BS_EXPORT CRenderable : public Component
-	{
-	public:
-		/**
-		 * @copydoc	Renderable::setMesh
-		 */
-		void setMesh(HMesh mesh) { mInternal->setMesh(mesh); }
-
-		/**
-		 * @copydoc	Renderable::setMaterial
-		 */
-		void setMaterial(UINT32 idx, HMaterial material) { mInternal->setMaterial(idx, material); }
-
-		/**
-		 * @copydoc	Renderable::setMaterial
-		 */
-		void setMaterial(HMaterial material) { mInternal->setMaterial(material); }
-
-		/**
-		 * @copydoc	Renderable::setLayer
-		 */
-		void setLayer(UINT64 layer) { mInternal->setLayer(layer); }
-
-		/**
-		 * @copydoc	Renderable::getLayer
-		 */
-		UINT64 getLayer() const { return mInternal->getLayer(); }
-
-		/**
-		 * @copydoc	Renderable::getMesh
-		 */
-		HMesh getMesh() const { return mInternal->getMesh(); }
-
-		/**
-		 * @copydoc	Renderable::getMaterial
-		 */
-		HMaterial getMaterial(UINT32 idx) const { return mInternal->getMaterial(idx); }
-
-		/**
-		 * @brief	Gets world bounds of the mesh rendered by this object.
-		 */
-		Bounds getBounds() const;
-
-		/**
-		 * @copydoc	Component::calculateBounds
-		 */
-		bool calculateBounds(Bounds& bounds) override;
-
-		/**
-		 * @brief	Returns the internal renderable that is used for
-		 *			majority of operations by this component.
-		 */
-		RenderablePtr _getRenderable() const { return mInternal; }
-
-	private:
-		/**
-		 * @brief	Updates the world transform if the SceneObject transform changed.
-		 */
-		void updateTransform() const;
-
-		mutable RenderablePtr mInternal;
-
-		/************************************************************************/
-		/* 							COMPONENT OVERRIDES                    		*/
-		/************************************************************************/
-
-	protected:
-		friend class SceneObject;
-
-		CRenderable(const HSceneObject& parent);
-
-		/**
-		 * @copydoc	Component::onInitialized
-		 */
-		void onInitialized() override;
-
-		/**
-		 * @copydoc	Component::onDestroyed
-		 */
-		void onDestroyed() override;
-
-	public:
-		/**
-		 * @copydoc	Component::update
-		 */
-		virtual void update() override;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class CRenderableRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const override;
-
-	protected:
-		CRenderable() {} // Serialization only
-	};
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsRenderable.h"
+#include "BsBounds.h"
+#include "BsComponent.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Components
+	 *  @{
+	 */
+
+	/**
+	 * @copydoc	Renderable
+	 * 			
+	 * Wraps a Renderable as a Component.
+	 */
+	class BS_EXPORT CRenderable : public Component
+	{
+	public:
+		/** @copydoc Renderable::setMesh */
+		void setMesh(HMesh mesh) { mInternal->setMesh(mesh); }
+
+		/** @copydoc Renderable::setMaterial */
+		void setMaterial(UINT32 idx, HMaterial material) { mInternal->setMaterial(idx, material); }
+
+		/** @copydoc Renderable::setMaterial */
+		void setMaterial(HMaterial material) { mInternal->setMaterial(material); }
+
+		/** @copydoc Renderable::setLayer */
+		void setLayer(UINT64 layer) { mInternal->setLayer(layer); }
+
+		/** @copydoc Renderable::getLayer */
+		UINT64 getLayer() const { return mInternal->getLayer(); }
+
+		/** @copydoc Renderable::getMesh */
+		HMesh getMesh() const { return mInternal->getMesh(); }
+
+		/** @copydoc Renderable::getMaterial */
+		HMaterial getMaterial(UINT32 idx) const { return mInternal->getMaterial(idx); }
+
+		/**	Gets world bounds of the mesh rendered by this object. */
+		Bounds getBounds() const;
+
+		/** @copydoc Component::calculateBounds */
+		bool calculateBounds(Bounds& bounds) override;
+
+		/** Returns the internal renderable that is used for majority of operations by this component. */
+		RenderablePtr _getRenderable() const { return mInternal; }
+
+	private:
+		/**	Updates the world transform if the SceneObject transform changed. */
+		void updateTransform() const;
+
+		mutable RenderablePtr mInternal;
+
+		/************************************************************************/
+		/* 							COMPONENT OVERRIDES                    		*/
+		/************************************************************************/
+
+	protected:
+		friend class SceneObject;
+
+		CRenderable(const HSceneObject& parent);
+
+		/** @copydoc Component::onInitialized */
+		void onInitialized() override;
+
+		/** @copydoc Component::onDestroyed */
+		void onDestroyed() override;
+
+	public:
+		/** @copydoc Component::update */
+		virtual void update() override;
+
+		/************************************************************************/
+		/* 								RTTI		                     		*/
+		/************************************************************************/
+	public:
+		friend class CRenderableRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const override;
+
+	protected:
+		CRenderable() {} // Serialization only
+	};
+
+	/** @} */
 }

BansheeEngine/Include/BsDragAndDropManager.h

@@ -8,9 +8,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Holds data returned by DragAndDropManager callbacks.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Holds data returned by DragAndDropManager callbacks. */
 	struct BS_EXPORT DragCallbackInfo
 	{
 		DragCallbackInfo()
@@ -21,9 +24,8 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Handles GUI drag and drop operations. When active GUI elements
-	 *			will be notified of any drag events and will be able to retrieve
-	 *			dragged data.
+	 * Handles GUI drag and drop operations. When active GUI elements will be notified of any drag events and will be able
+	 * to retrieve dragged data.
 	 *
 	 * @note	Sim thread only.
 	 */
@@ -34,87 +36,73 @@ namespace BansheeEngine
 		~DragAndDropManager();
 
 		/**
-		 * @brief	Starts a drag operation of the specified type. This means GUI elements will start receiving
-		 * 			drag and drop related events and they may choose to handle them.
+		 * Starts a drag operation of the specified type. This means GUI elements will start receiving drag and drop 
+		 * related events and they may choose to handle them.
 		 *
-		 * @param	typeId					Type of the drag and drop operation that other objects may query and decide if they want
-		 * 									to handle it. User defined.
-		 * @param 	data					Some operation specific data that is just passed through to however needs it.
-		 * @param	dropCallback			The drop callback that gets triggered whenever mouse button is released and drag operation ends.
-		 * 									You should perform any cleanup here.
-		 * @param	needsValidDropTarget	(optional) Determines whether the drop operation may happen anywhere or does the GUI element need to specifically
-		 * 									accept the drag of this type. If false all GUI elements we mouse over will receive drag/drop events, otherwise only
-		 * 									those that specifically subscribe to the specified drag operation of this typeId will.
-		 * 									
-		 *									Additionally this will determine the cursor displayed (whether or not it can have a "denied" state).
+		 * @param[in]	typeId					Type of the drag and drop operation that other objects may query and decide
+		 *										if they want to handle it. User defined.
+		 * @param[in] 	data					Some operation specific data that is just passed through to however needs it.
+		 * @param[in]	dropCallback			The drop callback that gets triggered whenever mouse button is released and
+		 *										drag operation ends. You should perform any cleanup here.
+		 * @param[in]	needsValidDropTarget	(optional) Determines whether the drop operation may happen anywhere or 
+		 *										does the GUI element need to specifically accept the drag of this type. 
+		 *										If false all GUI elements we mouse over will receive drag/drop events, 
+		 *										otherwise only those that specifically subscribe to the specified drag 
+		 *										operation of this typeId will.
+		 * 										Additionally this will determine the cursor displayed (whether or not it 
+		 *										can have a "denied" state).
 		 */
 		void startDrag(UINT32 typeId, void* data, std::function<void(bool)> dropCallback, bool needsValidDropTarget = false);
 
-		/**
-		 * @brief	Returns true if drag is currently in progress.
-		 */
+		/**	Returns true if drag is currently in progress. */
 		bool isDragInProgress() const { return mIsDragInProgress; }
 
-		/**
-		 * @brief	Get type ID of drag currently in progress. Only valid if drag is in progress.
-		 */
+		/**	Get type ID of drag currently in progress. Only valid if drag is in progress. */
 		UINT32 getDragTypeId() const { return mDragTypeId; }
 
-		/**
-		 * @brief	Gets drag specific data specified when the drag started. Only valid if drag is in progress.
-		 */
+		/**	Gets drag specific data specified when the drag started. Only valid if drag is in progress. */
 		void* getDragData() const { return mData; }
 
 		/**
-		 * @brief	Determines whether the drop operation may happen anywhere or does the GUI element need to specifically
-		 * 			accept the drag of this type. If false all GUI elements we mouse over will receive drag/drop events, otherwise only
-		 * 			those that specifically subscribe to the specified drag operation of this typeId will.
+		 * Determines whether the drop operation may happen anywhere or does the GUI element need to specifically accept the
+		 * drag of this type. If false all GUI elements we mouse over will receive drag/drop events, otherwise only those 
+		 * that specifically subscribe to the specified drag operation of this typeId will.
 		 * 									
-		 *			Additionally this will determine the cursor displayed (whether or not it can have a "denied" state).
+		 * Additionally this will determine the cursor displayed (whether or not it can have a "denied" state).
 		 */
 		bool needsValidDropTarget() const { return mNeedsValidDropTarget; }
 
 		/**
-		 * @brief	Registers a new callback that will be triggered when dragged item is dropped.
-		 *			Provided parameter specifies if the drop operation was handled by anyone or not.
+		 * Registers a new callback that will be triggered when dragged item is dropped. Provided parameter specifies if 
+		 * the drop operation was handled by anyone or not.
 		 */
 		void addDropCallback(std::function<void(bool)> dropCallback);
 
-		/**
-		 * @brief	Called once per frame.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Called once per frame. Checks if drag ended or if window loses focus. */
 		void _update();
 
 		/**
-		 * @brief	Triggers a callback when user releases the pointer and the drag operation ends.
-		 *			Provided parameters inform the subscriber where the pointer was released, and allows
-		 *			the subscriber to note whether the drag operation was processed or not.
+		 * Triggers a callback when user releases the pointer and the drag operation ends. Provided parameters inform the
+		 * subscriber where the pointer was released, and allows the subscriber to note whether the drag operation was 
+		 * processed or not.
 		 *
 		 * @note	Internal event. You should use addDropCallback for normal use.
 		 */
 		Event<void(const PointerEvent&, DragCallbackInfo&)> onDragEnded;
 	private:
 
-		/**
-		 * @brief	Triggers any drop callbacks and clears callback data.
-		 */
+		/**	Triggers any drop callbacks and clears callback data. */
 		void endDrag(bool processed);
 
 		/**
-		 * @brief	Called by the core thread whenever mouse capture state changes.
-		 *			This can happen when window loses focus (e.g. alt+tab). In that 
-		 *			case we want to end the drag even if the user is still holding 
-		 *			the dragged item.
+		 * Called by the core thread whenever mouse capture state changes. This can happen when window loses focus 
+		 * (e.g. alt+tab). In that case we want to end the drag even if the user is still holding the dragged item.
 		 *
 		 * @note	Core thread.
 		 */
 		void mouseCaptureChanged();
 
-		/**
-		 * @brief	Called by the input system when pointer is released.
-		 */
+		/**	Called by the input system when pointer is released. */
 		void cursorReleased(const PointerEvent& event);
 
 	private:
@@ -129,4 +117,7 @@ namespace BansheeEngine
 		std::atomic<int> mCaptureActive;
 		std::atomic<UINT64> mCaptureChangeFrame;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsDropDownAreaPlacement.h

@@ -6,10 +6,14 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Determines how will the drop down box be positioned. Usually the system will attempt to position
-	 * 			the drop box in a way so all elements can fit, and this class allows you to specify some limitations
-	 * 			on how that works. 
+	 * Determines how will the drop down box be positioned. Usually the system will attempt to position the drop box in a 
+	 * way so all elements can fit, and this class allows you to specify some limitations on how that works. 
 	 * 			
 	 * @note	For example, list boxes usually want drop down boxes to be placed above or below them, while
 	 * 			context menus may want to have them placed around a single point in any direction.
@@ -17,9 +21,7 @@ namespace BansheeEngine
 	class BS_EXPORT DropDownAreaPlacement
 	{
 	public:
-		/**
-		 * @brief	Determines how will the drop down box be positioned.
-		 */
+		/**	Determines how will the drop down box be positioned. */
 		enum class Type
 		{
 			Position,
@@ -29,8 +31,8 @@ namespace BansheeEngine
 		};
 
 		/**
-		 * @brief	Preferred horizontal direction of the placement bounds, either
-		 *			to the left or to the right of the wanted position/bounds.
+		 * Preferred horizontal direction of the placement bounds, either to the left or to the right of the wanted 
+		 * position/bounds.
 		 */
 		enum class HorzDir
 		{
@@ -38,8 +40,7 @@ namespace BansheeEngine
 		};
 
 		/**
-		 * @brief	Preferred horizontal direction of the placement bounds, either
-		 *			upward or downward of the wanted position/bounds.
+		 * Preferred horizontal direction of the placement bounds, either upward or downward of the wanted position/bounds.
 		 */
 		enum class VertDir
 		{
@@ -49,66 +50,63 @@ namespace BansheeEngine
 		DropDownAreaPlacement() { }
 
 		/**
-		 * @brief	Drop down box will be placed at the specified position. By default the system
-		 * 			prefers the top left corner of the box to correspond to the position, but if
-		 * 			other corners offer more space for the contents, those will be used instead.
+		 * Drop down box will be placed at the specified position. By default the system prefers the top left corner of the
+		 * box to correspond to the position, but if other corners offer more space for the contents, those will be used 
+		 * instead.
 		 */
 		static DropDownAreaPlacement aroundPosition(const Vector2I& position);
 
 		/**
-		 * @brief	Drop down box will be placed at the specified bounds. Box will be horizontally aligned to the left
-		 * 			of the provided bounds. Vertically system prefers placing the box at the bottom of the bounds, but may choose
-		 * 			to align it with the top of the bounds if it offers more space for the contents.
+		 * Drop down box will be placed at the specified bounds. Box will be horizontally aligned to the left of the 
+		 * provided bounds. Vertically system prefers placing the box at the bottom of the bounds, but may choose to align
+		 * it with the top of the bounds if it offers more space for the contents.
 		 */
 		static DropDownAreaPlacement aroundBoundsVert(const Rect2I& bounds);
 		
 		/**
-		 * @brief	Drop down box will be placed at the specified bounds. Box will be vertically aligned to the top
-		 * 			of the provided bounds. Horizontally system prefers placing the box at the right of the bounds, but may choose
-		 * 			to align it with the left of the bounds if it offers more space for the contents.
+		 * Drop down box will be placed at the specified bounds. Box will be vertically aligned to the top of the provided
+		 * bounds. Horizontally system prefers placing the box at the right of the bounds, but may choose to align it with
+		 * the left of the bounds if it offers more space for the contents.
 		 */
 		static DropDownAreaPlacement aroundBoundsHorz(const Rect2I& bounds);
 
 		/**
-		 * @brief	Drop down box will be placed at the specified bounds. Box will be vertically aligned to the top or bottom
-		 * 			of the provided bounds, with bottom being preferred. Horizontally system prefers placing the box at the 
-		 *			right of the bounds, but may choose to align it with the left of the bounds if it offers more space for 
-		 *			the contents.
+		 * Drop down box will be placed at the specified bounds. Box will be vertically aligned to the top or bottom of the
+		 * provided bounds, with bottom being preferred. Horizontally system prefers placing the box at the right of the
+		 * bounds, but may choose to align it with the left of the bounds if it offers more space for the contents.
 		 */
 		static DropDownAreaPlacement aroundBounds(const Rect2I& bounds);
 
-		/**
-		 * @brief	Returns drop down box positioning type.
-		 */
+		/**	Returns drop down box positioning type. */
 		Type getType() const { return mType; }
 
-		/**
-		 * @brief	Returns bounds around which to position the drop down box
-		 *			if one of the bounds positioning types is used.
-		 */
+		/** Returns bounds around which to position the drop down box if one of the bounds positioning types is used. */
 		const Rect2I& getBounds() const { return mBounds; }
 
-		/**
-		 * @brief	Returns position around which to position the drop down box
-		 *			if position positioning type is used.
-		 */
+		/**	Returns position around which to position the drop down box if position positioning type is used. */
 		const Vector2I& getPosition() const { return mPosition; }
 
 		/**
-		 * @brief	Calculates the optimal bounds to place an element of the specified size, within
-		 *			the available area using the internal data as a guide.
+		 * Calculates the optimal bounds to place an element of the specified size, within the available area using the 
+		 * internal data as a guide.
 		 *
-		 * @param	width	Width of the element to try to position, in pixels.
-		 * @param	height	Height of the element to try to position, in pixels.
-		 * @param	Rect2I	Available area to try to position the element in, in pixels.
-		 * @param	horzDir	Output parameter that signals the preferred horizontal direction of the bounds (left or right).
-		 * @param	vertDir	Output parameter that signals the preferred vertical direction of the bounds (up or down).
+		 * @param[in]	width			Width of the element to try to position, in pixels.
+		 * @param[in]	height			Height of the element to try to position, in pixels.
+		 * @param[in]	availableArea	Available area to try to position the element in, in pixels.
+		 * @param[in]	horzDir			Output parameter that signals the preferred horizontal direction of the bounds 
+		 *								(left or right).
+		 * @param[in]	vertDir			Output parameter that signals the preferred vertical direction of the bounds 
+		 *								(up or down).
 		 */
-		Rect2I getOptimalBounds(UINT32 width, UINT32 height, const Rect2I& availableArea, HorzDir& horzDir, VertDir& vertDir) const;
+		Rect2I getOptimalBounds(UINT32 width, UINT32 height, const Rect2I& availableArea, HorzDir& horzDir, 
+			VertDir& vertDir) const;
 
 	private:
 		Type mType;
 		Rect2I mBounds;
 		Vector2I mPosition;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIButton.h

@@ -2,17 +2,15 @@
 
 #include "BsPrerequisites.h"
 #include "BsGUIButtonBase.h"
-#include "BsImageSprite.h"
-#include "BsTextSprite.h"
 #include "BsGUIContent.h"
-#include "BsEvent.h"
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	GUI button that can be clicked. Has normal, hover and active states
-	 *			with an optional label.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** GUI button that can be clicked. Has normal, hover and active states with an optional label. */
 	class BS_EXPORT GUIButton : public GUIButtonBase
 	{
 	public:
@@ -24,52 +22,52 @@ namespace BansheeEngine
 		/**
 		 * Creates a new button with the specified label.
 		 *
-		 * @param	text			Label to display on the button.
-		 * @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 button style is used.
+		 * @param[in]	text		Label to display on the button.
+		 * @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 button style is used.
 		 */
 		static GUIButton* create(const HString& text, const String& styleName = StringUtil::BLANK);
 
 		/**
 		 * Creates a new button with the specified label.
 		 *
-		 * @param	text			Label to display on the button.
-		 * @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 button style is used.
+		 * @param[in]	text			Label to display on the button.
+		 * @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 button style is used.
 		 */
 		static GUIButton* create(const HString& text, const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
 		/**
 		 * Creates a new button with the specified label.
 		 *
-		 * @param	content		Content to display on a button. May include a label, image and a tooltip.
-		 * @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 button style is used.
+		 * @param[in]	content		Content to display on a button. May include a label, image and a tooltip.
+		 * @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 button style is used.
 		 */
 		static GUIButton* create(const GUIContent& content, const String& styleName = StringUtil::BLANK);
 
 		/**
 		 * Creates a new button with the specified label.
 		 *
-		 * @param	content			Content to display on a button. May include a label, image and a tooltip.
-		 * @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 button style is used.
+		 * @param[in]	content		Content to display on a button. May include a label, image and a tooltip.
+		 * @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 button style is used.
 		 */
 		static GUIButton* create(const GUIContent& content, const GUIOptions& options, const String& styleName = StringUtil::BLANK);
 
-		/**
-		 * @copydoc	GUIElement::getElementType
-		 */
+		/** @cond INTERNAL */
+
+		/** @copydoc GUIElement::getElementType */
 		virtual ElementType _getElementType() const override { return ElementType::Button; }
+
+		/** @endcond */
 	private:
 		GUIButton(const String& styleName, const GUIContent& content, const GUIDimensions& dimensions);
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIButtonBase.h

@@ -9,134 +9,95 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Base class for a clickable GUI button element.
-	 */	
+	/** @addtogroup Implementation
+	 *  @{
+	 */
+
+	/**	Base class for a clickable GUI button element. */	
 	class BS_EXPORT GUIButtonBase : public GUIElement
 	{
 	public:
-		/**
-		 * @brief	Change content displayed by the button.
-		 */
+		/**	Change content displayed by the button. */
 		void setContent(const GUIContent& content);
 
+		/** @cond INTERNAL */
+
 		/**
-		 * @brief	Change the button "on" state. This state determines
-		 *			whether the button uses normal or "on" fields specified
-		 *			in the GUI style.
+		 * Change the button "on" state. This state determines whether the button uses normal or "on" fields specified in 
+		 * the GUI style.
 		 */
 		void _setOn(bool on);
 
 		/**
-		 * @brief	Retrieves the button "on" state. This state determines
-		 *			whether the button uses normal or "on" fields specified
-		 *			in the GUI style.
+		 * Retrieves the button "on" state. This state determines whether the button uses normal or "on" fields specified
+		 * in the GUI style.
 		 */
 		bool _isOn() const;
 
-		/**
-		 * @brief	Change the internal button state, changing the button look depending on set style.
-		 */
+		/**	Change the internal button state, changing the button look depending on set style. */
 		void _setState(GUIElementState state);
 
-		/**
-		 * @copydoc	GUIElement::_getOptimalSize
-		 */
+		/** @copydoc GUIElement::_getOptimalSize */
 		virtual Vector2I _getOptimalSize() const override;
 
-		/**
-		 * @copydoc GUIElement::_getRenderElementDepthRange
-		 */
+		/** @copydoc GUIElement::_getRenderElementDepthRange */
 		virtual UINT32 _getRenderElementDepthRange() const override;
 
-		/**
-		 * @brief	Triggered when button is clicked.
-		 */
+		/** @endcond */
+
+		/**	Triggered when button is clicked. */
 		Event<void()> onClick;
 
-		/**
-		 * @brief	Triggered when pointer hovers over the button.
-		 */
+		/**	Triggered when pointer hovers over the button. */
 		Event<void()> onHover;
 
-		/**
-		 * @brief	Triggered when pointer that was previously hovering leaves the button.
-		 */
+		/**	Triggered when pointer that was previously hovering leaves the button. */
 		Event<void()> onOut;
 
-		/**
-		 * @brief	Triggered when button is clicked twice in rapid succession.
-		 */
+		/**	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();
 
-		/**
-		 * @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::mouseEvent
-		 */
+		/** @copydoc GUIElement::mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
-		/**
-		 * @copydoc GUIElement::_getRenderElementDepth
-		 */
+		/** @copydoc GUIElement::_getRenderElementDepth */
 		virtual UINT32 _getRenderElementDepth(UINT32 renderElementIdx) const override;
 
-		/**
-		 * @copydoc GUIElement::_getTooltip
-		 */
+		/** @copydoc GUIElement::_getTooltip */
 		virtual WString _getTooltip() const override;
 
-		/**
-		 * @brief	Creates or destroys the content image sprite depending if there is a content image for the
-		 *			active state.
-		 */
+		/** Creates or destroys the content image sprite depending if there is a content image for the active state. */
 		void refreshContentSprite();
 
-		/**
-		 * @brief	Gets the text sprite descriptor used for creating/updating the internal text sprite.
-		 */
+		/**	Gets the text sprite descriptor used for creating/updating the internal text sprite. */
 		TEXT_SPRITE_DESC getTextDesc() const;
 
-		/**
-		 * @brief	Retrieves internal button state.
-		 */
+		/**	Retrieves internal button state. */
 		GUIElementState getState() const { return mActiveState; }
 
-		/**
-		 * @brief	Returns the active sprite texture, depending on the current state.
-		 */
+		/**	Returns the active sprite texture, depending on the current state. */
 		const HSpriteTexture& getActiveTexture() const;
 
-		/**
-		 * @brief	Returns the active text color, depending on the current state.
-		 */
+		/**	Returns the active text color, depending on the current state. */
 		Color getActiveTextColor() const;
 	private:
 		ImageSprite* mImageSprite;
@@ -147,4 +108,6 @@ namespace BansheeEngine
 		IMAGE_SPRITE_DESC mImageDesc;
 		GUIContent mContent;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUICommandEvent.h

@@ -4,9 +4,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Type of valid command events.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Type of valid command events. */
 	enum class GUICommandEventType
 	{
 		Redraw, FocusLost, FocusGained, MoveLeft, MoveRight, MoveUp, MoveDown, 
@@ -14,8 +17,8 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Holds data about a GUI command event. Command events are special events
-	 *			with a more specific purpose than general input events.
+	 * Holds data about a GUI command event. Command events are special events with a more specific purpose than general
+	 * input events.
 	 */
 	class BS_EXPORT GUICommandEvent
 	{
@@ -24,18 +27,17 @@ namespace BansheeEngine
 			:mType(GUICommandEventType::Redraw)
 		{ }
 
-		/**
-		 * @brief	Returns type describing what kind of event this is.
-		 */
+		/**	Returns type describing what kind of event this is. */
 		GUICommandEventType getType() const { return mType; }
 	private:
 		friend class GUIManager;
 
-		/**
-		 * @brief	Sets type describing what kind of event this is.
-		 */
+		/**	Sets type describing what kind of event this is. */
 		void setType(GUICommandEventType type) { mType = type; }
 
 		GUICommandEventType mType;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIContent.h

@@ -3,9 +3,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Type of GUI element states.
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Type of GUI element states. */
 	enum class GUIElementState
 	{
 		Normal = 0x01, /**< Normal state when button is not being iteracted with. */
@@ -18,9 +20,7 @@ namespace BansheeEngine
 		FocusedOn = 0x18 /**< State when button has been selected and is in "on" state. */
 	};
 
-	/**
-	 * @brief	Contains separate GUI content images for every possible GUI element state.
-	 */
+	/**	Contains separate GUI content images for every possible GUI element state. */
 	struct BS_EXPORT GUIContentImages
 	{
 		GUIContentImages() {}
@@ -37,69 +37,49 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Holds data used for displaying content in a GUIElement. 
-	 *			Content can consist of a string, image, a tooltip or none of those.
+	 * Holds data used for displaying content in a GUIElement. Content can consist of a string, image, a tooltip or none 
+	 * of those.
 	 */
 	class BS_EXPORT GUIContent
 	{
 	public:
-		/**
-		 * @brief	Constructs an empty content.
-		 */
+		/**	Constructs an empty content. */
 		GUIContent();
 
-		/**
-		 * @brief	Constructs content with just a string.
-		 */
+		/**	Constructs content with just a string. */
 		GUIContent(const HString& text);
 
-		/**
-		 * @brief	Constructs content with a string and a tooltip.
-		 */
+		/**	Constructs content with a string and a tooltip. */
 		GUIContent(const HString& text, const HString& tooltip);
 
-		/**
-		 * @brief	Constructs content with just an image.
-		 */
+		/**	Constructs content with just an image. */
 		GUIContent(const GUIContentImages& image);
 
-		/**
-		 * @brief	Constructs content with an image and a tooltip.
-		 */
+		/**	Constructs content with an image and a tooltip. */
 		GUIContent(const HSpriteTexture& image, const HString& tooltip);
 
-		/**
-		 * @brief	Constructs content with a string and an image. 
-		 */
+		/**	Constructs content with a string and an image. */
 		GUIContent(const HString& text, const GUIContentImages& image);
 
-		/**
-		 * @brief	Constructs content with a string, an image and a tooltip. 
-		 */
+		/**	Constructs content with a string, an image and a tooltip. */
 		GUIContent(const HString& text, const GUIContentImages& image, const HString& tooltip);
 
-		/**
-		 * @brief	Returns string content (if any).
-		 */
+		/**	Returns string content (if any). */
 		const HString& getText() const { return mText; }
 
-		/**
-		 * @brief	Returns image content (if any).
-		 */
+		/**	Returns image content (if any). */
 		const HSpriteTexture& getImage(GUIElementState state = GUIElementState::Normal) const;
 
-		/**
-		 * @brief	Returns tooltip content (if any).
-		 */
+		/**	Returns tooltip content (if any). */
 		const HString& getTooltip() const { return mTooltipText; }
 
-		/**
-		 * @brief	Determines the spacing between text and image content in pixels.
-		 */
+		/**	Determines the spacing between text and image content in pixels. */
 		static const UINT32 IMAGE_TEXT_SPACING;
 	private:
 		HString mText;
 		GUIContentImages mImages;
 		HString mTooltipText;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIContextMenu.h

@@ -5,10 +5,13 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Manages display and logic for a context menu.
-	 *			Context menus can be opened anywhere within the GUI
-	 *			and can contain a hierarchy of menu items. 
+	 * Manages display and logic for a context menu. Context menus can be opened anywhere within the GUI and can contain a
+	 * hierarchy of menu items. 
 	 */
 	class BS_EXPORT GUIContextMenu : public GUIMenu
 	{
@@ -16,25 +19,19 @@ namespace BansheeEngine
 		GUIContextMenu();
 		~GUIContextMenu();
 
-		/**
-		 * @brief	Opens a context menu at the specified position relative
-		 *			to the provided widget.
-		 */
+		/** Opens a context menu at the specified position relative to the provided widget. */
 		void open(const Vector2I& position, GUIWidget& widget);
 
 	private:
-		/**
-		 * @brief	Closes the context menu if open.
-		 */
+		/**	Closes the context menu if open. */
 		void close();
 
-		/**
-		 * @brief	Called when the context menu is closed externally
-		 *			(e.g. when user selects an item or clicks outside it).
-		 */
+		/**	Called when the context menu is closed externally (e.g. when user selects an item or clicks outside it). */
 		void onMenuClosed();
 
 	private:
 		bool mContextMenuOpen;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIDimensions.h

@@ -1,83 +1,73 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsVector2I.h"
-
-namespace BansheeEngine
-{
-	/**
-	 * @brief	Contains valid size range for a GUI element in a GUI layout.
-	 */
-	struct BS_EXPORT LayoutSizeRange
-	{
-		Vector2I optimal;
-		Vector2I min;
-		Vector2I max;
-	};
-
-	/**
-	 * @brief	Flags that identify the type of data stored in a GUIDimensions structure.
-	 */
-	enum GUIDimensionFlags
-	{
-		GUIDF_FixedWidth = 0x01, 
-		GUIDF_FixedHeight = 0x02, 
-		GUIDF_OverWidth = 0x04, 
-		GUIDF_OverHeight = 0x08
-	};
-
-	/**
-	 * @brief	Options that control how an element is positioned and sized.
-	 */
-	struct BS_EXPORT GUIDimensions
-	{
-		/**
-		 * @brief	Creates new default layout options.
-		 */
-		static GUIDimensions create();
-
-		/**
-		 * @brief	Creates layout options with user defined options.
-		 */
-		static GUIDimensions create(const GUIOptions& options);
-
-		GUIDimensions();
-
-		/**
-		 * @brief	Updates layout options from the provided style. If user has not manually
-		 *			set a specific layout property, that property will be inherited from style.
-		 */
-		void updateWithStyle(const GUIElementStyle* style);
-
-		/**
-		 * @brief	Calculates size range for a GUI element using this layout.
-		 *
-		 * @param	optimal	Preferred size of the GUI element.
-		 */
-		LayoutSizeRange calculateSizeRange(const Vector2I& optimal) const;
-
-		/**
-		 * @brief	Checks do the dimensions override the style height.
-		 */
-		bool overridenHeight() const { return (flags & GUIDF_OverHeight) != 0; }
-
-		/**
-		 * @brief	Checks do the dimensions override the style width.
-		 */
-		bool overridenWidth() const { return (flags & GUIDF_OverWidth) != 0; }
-
-		/**
-		 * @brief	Checks do the dimensions contain fixed width.
-		 */
-		bool fixedWidth() const { return (flags & GUIDF_FixedWidth) != 0; }
-
-		/**
-		 * @brief	Checks do the dimensions contain fixed height.
-		 */
-		bool fixedHeight() const { return (flags & GUIDF_FixedHeight) != 0; }
-
-		INT32 x, y;
-		UINT32 minWidth, maxWidth, minHeight, maxHeight;
-		UINT32 flags;
-	};
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsVector2I.h"
+
+namespace BansheeEngine
+{
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
+	/**	Contains valid size range for a GUI element in a GUI layout. */
+	struct BS_EXPORT LayoutSizeRange
+	{
+		Vector2I optimal;
+		Vector2I min;
+		Vector2I max;
+	};
+
+	/**	Flags that identify the type of data stored in a GUIDimensions structure. */
+	enum GUIDimensionFlags
+	{
+		GUIDF_FixedWidth = 0x01, 
+		GUIDF_FixedHeight = 0x02, 
+		GUIDF_OverWidth = 0x04, 
+		GUIDF_OverHeight = 0x08
+	};
+
+	/**	Options that control how an element is positioned and sized. */
+	struct BS_EXPORT GUIDimensions
+	{
+		/**	Creates new default layout options. */
+		static GUIDimensions create();
+
+		/**	Creates layout options with user defined options. */
+		static GUIDimensions create(const GUIOptions& options);
+
+		GUIDimensions();
+
+		/**
+		 * Updates layout options from the provided style. If user has not manually set a specific layout property, that
+		 * property will be inherited from style.
+		 */
+		void updateWithStyle(const GUIElementStyle* style);
+
+		/**
+		 * Calculates size range for a GUI element using this layout.
+		 *
+		 * @param[in]	optimal	Preferred size of the GUI element.
+		 */
+		LayoutSizeRange calculateSizeRange(const Vector2I& optimal) const;
+
+		/**	Checks do the dimensions override the style height. */
+		bool overridenHeight() const { return (flags & GUIDF_OverHeight) != 0; }
+
+		/**	Checks do the dimensions override the style width. */
+		bool overridenWidth() const { return (flags & GUIDF_OverWidth) != 0; }
+
+		/**	Checks do the dimensions contain fixed width. */
+		bool fixedWidth() const { return (flags & GUIDF_FixedWidth) != 0; }
+
+		/**	Checks do the dimensions contain fixed height. */
+		bool fixedHeight() const { return (flags & GUIDF_FixedHeight) != 0; }
+
+		INT32 x, y;
+		UINT32 minWidth, maxWidth, minHeight, maxHeight;
+		UINT32 flags;
+	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIDropDownBoxManager.h

@@ -6,28 +6,29 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Manages opening and closing of a drop down box.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Manages opening and closing of a drop down box. */
 	class BS_EXPORT GUIDropDownBoxManager : public Module<GUIDropDownBoxManager>
 	{
 	public:
 		~GUIDropDownBoxManager();
 
 		/**
-		 * @brief	Opens a new drop down box at the specified location, look and elements. This will close
-		 *			any previously open drop down box.
+		 * Opens a new drop down box at the specified location, look and elements. This will close any previously open drop
+		 * down box.
 		 *
-		 * @param	desc				Various parameters for initializing the drop down box.
-		 * @param	type				Specific type of drop down box to display.
-		 * @param	onClosedCallback	Callback triggered when drop down box is closed.
+		 * @param[in]	desc				Various parameters for initializing the drop down box.
+		 * @param[in]	type				Specific type of drop down box to display.
+		 * @param[in]	onClosedCallback	Callback triggered when drop down box is closed.
 		 */
 		GameObjectHandle<GUIDropDownMenu> openDropDownBox(const DROP_DOWN_BOX_DESC& desc, 
 			GUIDropDownType type, std::function<void()> onClosedCallback);
 
-		/**
-		 * @brief	Closes the currently active drop down box (if any).
-		 */
+		/**	Closes the currently active drop down box (if any). */
 		void closeDropDownBox();
 
 	private:
@@ -35,4 +36,7 @@ namespace BansheeEngine
 		GameObjectHandle<GUIDropDownMenu> mDropDownBox;
 		std::function<void()> mOnClosedCallback;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIDropDownContent.h

@@ -1,144 +1,129 @@
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsGUIElementContainer.h"
-#include "BsGUIDropDownMenu.h"
-
-namespace BansheeEngine
-{
-	/**
-	 * @brief	GUI element that is used for representing entries in a drop down menu.
-	 */
-	class BS_EXPORT GUIDropDownContent : public GUIElementContainer
-	{
-		/**
-		 * @brief	Contains various GUI elements used for displaying a single menu entry.
-		 */
-		struct VisibleElement
-		{
-			UINT32 idx = 0;
-			GUIButtonBase* button = nullptr;
-			GUITexture* separator = nullptr;
-			GUILabel* shortcutLabel = nullptr;
-		};
-
-	public:
-		/**
-		 * Returns type name of the GUI element used for finding GUI element styles. 
-		 */
-		static const String& getGUITypeName();
-
-		/**
-		 * @brief	Creates a new drop down contents element.
-		 *
-		 * @param	parent			Parent sub-menu that owns the drop down contents.
-		 * @param	dropDownData	Data that will be used for initializing the child entries.
-		 * @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 button style is used.
-		 */
-		static GUIDropDownContent* create(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData,
-			const String& style = StringUtil::BLANK);
-
-		/**
-		 * @brief	Creates a new drop down contents element.
-		 *
-		 * @param	parent			Parent sub-menu that owns the drop down contents.
-		 * @param	dropDownData	Data that will be used for initializing the child entries.
-		 * @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 button style is used.
-		 */
-		static GUIDropDownContent* create(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData, 
-			const GUIOptions& options, const String& style = StringUtil::BLANK);
-
-		/**
-		 * @brief	Changes the range of the displayed elements. 
-		 *
-		 * @note	This must be called at least once after creation.
-		 */
-		void setRange(UINT32 start, UINT32 end);
-
-		/**
-		 * @brief	Returns height of a menu element at the specified index, in pixels.
-		 */
-		UINT32 getElementHeight(UINT32 idx) const;
-
-		/**
-		 * @brief	Enables or disables keyboard focus. When keyboard focus is enabled the contents
-		 *			will respond to keyboard events.
-		 */
-		void setKeyboardFocus(bool focus);
-
-		static const String ENTRY_TOGGLE_STYLE_TYPE;
-		static const String ENTRY_STYLE_TYPE;
-		static const String ENTRY_EXP_STYLE_TYPE;
-		static const String SEPARATOR_STYLE_TYPE;
-	protected:
-		GUIDropDownContent(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData, 
-			const String& style, const GUIDimensions& dimensions);
-		~GUIDropDownContent() override;
-
-		/**
-		 * @brief	Get localized name of a menu item element with the specified index.
-		 */
-		HString getElementLocalizedName(UINT32 idx) const;
-
-		/**
-		 * @copydoc	GUIElementContainer::_getOptimalSize
-		 */
-		Vector2I _getOptimalSize() const override;
-
-		/**
-		 * @copydoc	GUIElementContainer::_updateLayoutInternal
-		 */
-		void _updateLayoutInternal(const GUILayoutData& data) override;
-
-		/**
-		 * @copydoc	GUIElementContainer::styleUpdated
-		 */
-		void styleUpdated() override;
-
-		/**
-		 * @copydoc	GUIElementContainer::_commandEvent
-		 */
-		bool _commandEvent(const GUICommandEvent& ev) override;
-
-		/**
-		 * @copydoc	GUIElementContainer::_mouseEvent
-		 */
-		bool _mouseEvent(const GUIMouseEvent& ev) override;
-
-		/**
-		 * @brief	Marks the element with the specified index as selected.
-		 * 		
-		 * @param	Index of the displayed element (indexing visible elements).
-		 */
-		void setSelected(UINT32 idx);
-
-		/**
-		 * @brief	Selects the next available non-separator entry.
-		 * 			
-		 * @param	Index of the menu element.
-		 */
-		void selectNext(UINT32 startIdx);
-
-		/**
-		 * @brief	Selects the previous available non-separator entry.
-		 * 			
-		 * @param	Index of the menu element.
-		 */
-		void selectPrevious(UINT32 startIdx);
-
-		GUIDropDownData mDropDownData;
-		Vector<bool> mStates;
-		Vector<VisibleElement> mVisibleElements;
-		UINT32 mSelectedIdx;
-		UINT32 mRangeStart, mRangeEnd;
-		GUIDropDownMenu::DropDownSubMenu* mParent;
-		bool mKeyboardFocus;
-		bool mIsToggle;
-	};
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsGUIElementContainer.h"
+#include "BsGUIDropDownMenu.h"
+
+namespace BansheeEngine
+{
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
+	 */
+
+	/**	GUI element that is used for representing entries in a drop down menu. */
+	class BS_EXPORT GUIDropDownContent : public GUIElementContainer
+	{
+		/**	Contains various GUI elements used for displaying a single menu entry. */
+		struct VisibleElement
+		{
+			UINT32 idx = 0;
+			GUIButtonBase* button = nullptr;
+			GUITexture* separator = nullptr;
+			GUILabel* shortcutLabel = nullptr;
+		};
+
+	public:
+		/** Returns type name of the GUI element used for finding GUI element styles.  */
+		static const String& getGUITypeName();
+
+		/**
+		 * Creates a new drop down contents element.
+		 *
+		 * @param[in]	parent			Parent sub-menu that owns the drop down contents.
+		 * @param[in]	dropDownData	Data that will be used for initializing the child entries.
+		 * @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 button style is used.
+		 */
+		static GUIDropDownContent* create(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData,
+			const String& style = StringUtil::BLANK);
+
+		/**
+		 * Creates a new drop down contents element.
+		 *
+		 * @param[in]	parent			Parent sub-menu that owns the drop down contents.
+		 * @param[in]	dropDownData	Data that will be used for initializing the child entries.
+		 * @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 button style is used.
+		 */
+		static GUIDropDownContent* create(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData, 
+			const GUIOptions& options, const String& style = StringUtil::BLANK);
+
+		/**
+		 * Changes the range of the displayed elements. 
+		 *
+		 * @note	This must be called at least once after creation.
+		 */
+		void setRange(UINT32 start, UINT32 end);
+
+		/**	Returns height of a menu element at the specified index, in pixels. */
+		UINT32 getElementHeight(UINT32 idx) const;
+
+		/**
+		 * Enables or disables keyboard focus. When keyboard focus is enabled the contents will respond to keyboard events.
+		 */
+		void setKeyboardFocus(bool focus);
+
+		static const String ENTRY_TOGGLE_STYLE_TYPE;
+		static const String ENTRY_STYLE_TYPE;
+		static const String ENTRY_EXP_STYLE_TYPE;
+		static const String SEPARATOR_STYLE_TYPE;
+	protected:
+		GUIDropDownContent(GUIDropDownMenu::DropDownSubMenu* parent, const GUIDropDownData& dropDownData, 
+			const String& style, const GUIDimensions& dimensions);
+		~GUIDropDownContent() override;
+
+		/**	Get localized name of a menu item element with the specified index. */
+		HString getElementLocalizedName(UINT32 idx) const;
+
+		/** @copydoc GUIElementContainer::_getOptimalSize */
+		Vector2I _getOptimalSize() const override;
+
+		/** @copydoc GUIElementContainer::_updateLayoutInternal */
+		void _updateLayoutInternal(const GUILayoutData& data) override;
+
+		/** @copydoc GUIElementContainer::styleUpdated */
+		void styleUpdated() override;
+
+		/** @copydoc GUIElementContainer::_commandEvent */
+		bool _commandEvent(const GUICommandEvent& ev) override;
+
+		/** @copydoc GUIElementContainer::_mouseEvent */
+		bool _mouseEvent(const GUIMouseEvent& ev) override;
+
+		/**
+		 * Marks the element with the specified index as selected.
+		 * 		
+		 * @param[in]	Index of the displayed element (indexing visible elements).
+		 */
+		void setSelected(UINT32 idx);
+
+		/**
+		 * Selects the next available non-separator entry.
+		 * 			
+		 * @param[in]	Index of the menu element.
+		 */
+		void selectNext(UINT32 startIdx);
+
+		/**
+		 * Selects the previous available non-separator entry.
+		 * 			
+		 * @param[in]	Index of the menu element.
+		 */
+		void selectPrevious(UINT32 startIdx);
+
+		GUIDropDownData mDropDownData;
+		Vector<bool> mStates;
+		Vector<VisibleElement> mVisibleElements;
+		UINT32 mSelectedIdx;
+		UINT32 mRangeStart, mRangeEnd;
+		GUIDropDownMenu::DropDownSubMenu* mParent;
+		bool mKeyboardFocus;
+		bool mIsToggle;
+	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIDropDownHitBox.h

@@ -5,85 +5,72 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * Helper class used for detecting when a certain area is in focus,
-	 * and getting notified when that state changes.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/** Helper class used for detecting when a certain area is in focus, and getting notified when that state changes. */
 	class BS_EXPORT GUIDropDownHitBox : 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();
 
 		/**
 		 * Creates a new drop down hit box that will detect mouse input over certain area.
-		 * You must call "setBounds" to define the area.
+		 * You must call setBounds() to define the area.
 		 *
-		 * @param	captureMouseOver	If true mouse over/out/move events will be captured by this control 
-		 *								and wont be passed to other GUI elements.
-		 * @param	captureMousePresses	If true mouse clicks will be captured by this control and wont be passed
-		 *								to other GUI elements.
+		 * @param[in]	captureMouseOver	If true mouse over/out/move events will be captured by this control and wont be
+		 *									passed to other GUI elements.
+		 * @param[in]	captureMousePresses	If true mouse clicks will be captured by this control and wont be passed
+		 *									to other GUI elements.
 		 */
 		static GUIDropDownHitBox* create(bool captureMouseOver, bool captureMousePresses);
 
 		/**
-		 * Creates a new drop down hit box that will detect mouse input over certain area.
-		 * You must call "setBounds" to define the area.
+		 * Creates a new drop down hit box that will detect mouse input over certain area. You must call setBounds() to 
+		 * define the area.
 		 *
-		 * @param	captureMouseOver	If true mouse over/out/move events will be captured by this control
-		 *								and wont be passed to other GUI elements.
-		 * @param	captureMousePresses	If true mouse clicks will be captured by this control and wont be passed
-		 *								to other GUI elements.
+		 * @param[in]	captureMouseOver	If true mouse over/out/move events will be captured by this control and wont be
+		 *									passed to other GUI elements.
+		 * @param[in]	captureMousePresses	If true mouse clicks will be captured by this control and wont be passed to 
+		 *									other GUI elements.
 		 */
 		static GUIDropDownHitBox* create(bool captureMouseOver, bool captureMousePresses, const GUIOptions& options);
 
-		/**
-		 * Sets a single rectangle bounds in which the hitbox will capture mouse events.
-		 */
+		/** Sets a single rectangle bounds in which the hitbox will capture mouse events. */
 		void setBounds(const Rect2I& bounds);
 
-		/**
-		 * Sets complex bounds consisting of multiple rectangles in which the hitbox will capture mouse events.
-		 */
+		/** Sets complex bounds consisting of multiple rectangles in which the hitbox will capture mouse events. */
 		void setBounds(const Vector<Rect2I>& bounds);
 
-		/**
-		 * Triggered when hit box loses focus (e.g. user clicks outside of its bounds).
-		 */
+		/** Triggered when hit box loses focus (e.g. user clicks outside of its bounds). */
 		Event<void()> onFocusLost;
 
-		/**
-		 * Triggered when hit box gains focus (e.g. user clicks inside of its bounds).
-		 */
+		/** Triggered when hit box gains focus (e.g. user clicks inside of its bounds). */
 		Event<void()> onFocusGained;
 
 	private:
 		GUIDropDownHitBox(bool captureMouseOver, bool captureMousePresses, const GUIDimensions& dimensions);
 
-		/**
-		 * @copydoc	GUIElementContainer::updateClippedBounds
-		 */
+		/** @copydoc GUIElementContainer::updateClippedBounds */
 		void updateClippedBounds() override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_commandEvent
-		 */
+		/** @copydoc GUIElementContainer::_commandEvent */
 		virtual bool _commandEvent(const GUICommandEvent& ev) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_mouseEvent
-		 */
+		/** @copydoc GUIElementContainer::_mouseEvent */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev) override;
 
-		/**
-		 * @copydoc	GUIElementContainer::_isInBounds
-		 */
+		/** @copydoc GUIElementContainer::_isInBounds */
 		virtual bool _isInBounds(const Vector2I position) const override;
 
 		Vector<Rect2I> mBounds;
 		bool mCaptureMouseOver;
 		bool mCaptureMousePresses;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIDropDownMenu.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains items used for initializing one level in a drop down box hierarchy.
+	/** @cond INTERNAL */
+	/** @addtogroup GUI
+	 *  @{
 	 */
+
+	/**	Contains items used for initializing one level in a drop down box hierarchy. */
 	struct BS_EXPORT GUIDropDownData
 	{
 		Vector<GUIDropDownDataEntry> entries;
@@ -17,21 +20,18 @@ namespace BansheeEngine
 		UnorderedMap<WString, HString> localizedNames;
 	};
 
-	/**
-	 * @brief	A set of parameters used for initializing a drop down box.
-	 */
+	/**	A set of parameters used for initializing a drop down box. */
 	struct DROP_DOWN_BOX_DESC
 	{
 		CameraPtr camera; /**< Camera on which to open the drop down box. */
 		DropDownAreaPlacement placement; /**< Determines how is the drop down box positioned in the visible area. */
 		GUIDropDownData dropDownData; /**< Data to use for initializing menu items of the drop down box. */
 		HGUISkin skin; /**< Skin to use for drop down box GUI elements. */
-		Vector<Rect2I> additionalBounds; /**< Additional bounds that control what is considered the inside or the outside of the drop down box. */
+		/** Additional bounds that control what is considered the inside or the outside of the drop down box. */
+		Vector<Rect2I> additionalBounds;
 	};
 
-	/**
-	 * @brief	Represents a single entry in a drop down box.
-	 */
+	/**	Represents a single entry in a drop down box. */
 	class BS_EXPORT GUIDropDownDataEntry
 	{
 		enum class Type
@@ -42,51 +42,32 @@ namespace BansheeEngine
 		};
 
 	public:
-		/**
-		 * @brief	Creates a new separator entry.
-		 */
+		/**	Creates a new separator entry. */
 		static GUIDropDownDataEntry separator();
 
-		/**
-		 * @brief	Creates a new button entry with the specified callback that is triggered
-		 *			when button is selected.
-		 */
-		static GUIDropDownDataEntry button(const WString& label, std::function<void()> callback, const WString& shortcutTag = StringUtil::WBLANK);
+		/** Creates a new button entry with the specified callback that is triggered when button is selected. */
+		static GUIDropDownDataEntry button(const WString& label, std::function<void()> callback, 
+			const WString& shortcutTag = StringUtil::WBLANK);
 
-		/**
-		 * @brief	Creates a new sub-menu entry that will open the provided drop down data
-		 *			sub-menu when activated.
-		 */
+		/** Creates a new sub-menu entry that will open the provided drop down data sub-menu when activated. */
 		static GUIDropDownDataEntry subMenu(const WString& label, const GUIDropDownData& data);
 
-		/**
-		 * @brief	Check is the entry a separator.
-		 */
+		/**	Check is the entry a separator. */
 		bool isSeparator() const { return mType == Type::Separator; }
 
-		/**
-		 * @brief	Check is the entry a sub menu.
-		 */
+		/**	Check is the entry a sub menu. */
 		bool isSubMenu() const { return mType == Type::SubMenu; }
 
-		/**
-		 * @brief	Returns display label of the entry (if an entry is a button or a sub-menu).
-		 */
+		/**	Returns display label of the entry (if an entry is a button or a sub-menu). */
 		const WString& getLabel() const { return mLabel; }
 
-		/**
-		 * @brief	Returns the shortcut key combination string that is to be displayed along the entry label.
-		 */
+		/**	Returns the shortcut key combination string that is to be displayed along the entry label. */
 		const WString& getShortcutTag() const { return mShortcutTag; }
 
-		/**
-		 * @brief	Returns a button callback if the entry (if an entry is a button).
-		 */
+		/**	Returns a button callback if the entry (if an entry is a button). */
 		std::function<void()> getCallback() const { return mCallback; }
 
-		/**
-		 * @brief	Returns sub-menu data that is used for creating a sub-menu (if an entry is a sub-menu).
-		 */
+		/**	Returns sub-menu data that is used for creating a sub-menu (if an entry is a sub-menu). */
 		const GUIDropDownData& getSubMenuData() const { return mChildData; }
 	private:
 		GUIDropDownDataEntry() { }
@@ -98,9 +79,7 @@ namespace BansheeEngine
 		Type mType; 
 	};
 
-	/**
-	 * @brief	Type of drop down box types.
-	 */
+	/**	Type of drop down box types. */
 	enum class GUIDropDownType
 	{
 		ListBox,
@@ -109,32 +88,25 @@ namespace BansheeEngine
 		MenuBar
 	};
 
-	/**
-	 * @brief	This is a generic GUI drop down box class that can be used for:
-	 * 			list boxes, menu bars or context menus.
-	 */
+	/**	This is a generic GUI drop down box class that can be used for: list boxes, menu bars or context menus. */
 	class BS_EXPORT GUIDropDownMenu : public CGUIWidget
 	{
 	public:
 		/**
-		 * @brief	Creates a new drop down box widget.
+		 * Creates a new drop down box widget.
 		 *
-		 * @param	parent			Parent scene object to attach the drop down box to.
-		 * @param	desc			Various parameters that control the drop down menu features and content.
-		 * @param	type			Specific type of drop down box to display.
+		 * @param[in]	parent	Parent scene object to attach the drop down box to.
+		 * @param[in]	desc	Various parameters that control the drop down menu features and content.
+		 * @param[in]	type	Specific type of drop down box to display.
 		 */
 		GUIDropDownMenu(const HSceneObject& parent, const DROP_DOWN_BOX_DESC& desc, GUIDropDownType type);
 		~GUIDropDownMenu();
 
 	private:
-		/**
-		 * @brief	Contains data about a single drop down box sub-menu
-		 */
+		/**	Contains data about a single drop down box sub-menu. */
 		struct DropDownSubMenu
 		{
-			/**
-			 * @brief	Represents a single sub-menu page.
-			 */
+			/**	Represents a single sub-menu page. */
 			struct PageInfo
 			{
 				UINT32 idx;
@@ -145,90 +117,68 @@ namespace BansheeEngine
 
 		public:
 			/**
-			 * @brief	Creates a new drop down box sub-menu
+			 * Creates a new drop down box sub-menu.
 			 *
-			 * @param	owner			Owner drop down box this sub menu belongs to.
-			 * @param	parent			Parent sub-menu. Can be null.
-			 * @param	placement		Determines how is the sub-menu positioned in the visible area.
-			 * @param	availableBounds	Available bounds (in pixels) in which the sub-menu may be opened.
-			 * @param	dropDownData	Data to use for initializing menu items of the sub-menu.
-			 * @param	skin			Skin to use for sub-menu GUI elements.
-			 * @param	depthOffset		How much to offset the sub-menu depth. We want deeper levels of the
-			 *							sub-menu hierarchy to be in front of lower levels, so you should
-			 *							increase this value for each level of the sub-menu hierarchy.
+			 * @param[in]	owner			Owner drop down box this sub menu belongs to.
+			 * @param[in]	parent			Parent sub-menu. Can be null.
+			 * @param[in]	placement		Determines how is the sub-menu positioned in the visible area.
+			 * @param[in]	availableBounds	Available bounds (in pixels) in which the sub-menu may be opened.
+			 * @param[in]	dropDownData	Data to use for initializing menu items of the sub-menu.
+			 * @param[in]	skin			Skin to use for sub-menu GUI elements.
+			 * @param[in]	depthOffset		How much to offset the sub-menu depth. We want deeper levels of the sub-menu
+			 *								hierarchy to be in front of lower levels, so you should increase this value for
+			 *								each level of the sub-menu hierarchy.
 			 */
 			DropDownSubMenu(GUIDropDownMenu* owner, DropDownSubMenu* parent, const DropDownAreaPlacement& placement, 
 				const Rect2I& availableBounds, const GUIDropDownData& dropDownData, GUIDropDownType type, UINT32 depthOffset);
 			~DropDownSubMenu();
 
-			/**
-			 * @brief	Recreates all internal GUI elements for the entries of the current sub-menu page.
-			 */
+			/**	Recreates all internal GUI elements for the entries of the current sub-menu page. */
 			void updateGUIElements();
 
-			/**
-			 * @brief	Moves the sub-menu to the previous page and displays its elements, if available.
-			 */
+			/**	Moves the sub-menu to the previous page and displays its elements, if available. */
 			void scrollDown();
 
-			/**
-			 * @brief	Moves the sub-menu to the next page and displays its elements, if available.
-			 */
+			/**	Moves the sub-menu to the next page and displays its elements, if available. */
 			void scrollUp();
 
-			/**
-			 * @brief	Moves the sub-menu to the first page and displays its elements.
-			 */
+			/**	Moves the sub-menu to the first page and displays its elements. */
 			void scrollToTop();
 
-			/**
-			 * @brief	Moves the sub-menu to the last page and displays its elements.
-			 */
+			/**	Moves the sub-menu to the last page and displays its elements. */
 			void scrollToBottom();
 
-			/**
-			 * @brief	Calculates ranges for all the pages of the sub-menu.
-			 */
+			/**	Calculates ranges for all the pages of the sub-menu. */
 			Vector<PageInfo> getPageInfos() const;
 
 			/**
-			 * @brief	Called when the user activates an element with the specified index.
+			 * Called when the user activates an element with the specified index.
 			 *
-			 * @param	bounds	Bounds of the GUI element that is used as a visual representation
-			 *					of this drop down element.
+			 * @param[in]	bounds	Bounds of the GUI element that is used as a visual representation of this drop down 
+			 *						element.
 			 */
 			void elementActivated(UINT32 idx, const Rect2I& bounds);
 
 			/**
-			 * @brief	Called when the user selects an element with the specified index.
+			 * Called when the user selects an element with the specified index.
 			 * 
-			 * @param	idx		Index of the element that was selected.
+			 * @param[in]	idx		Index of the element that was selected.
 			 */
 			void elementSelected(UINT32 idx);
 
-			/**
-			 * @brief	Called when the user wants to close the currently open sub-menu.
-			 */
+			/**	Called when the user wants to close the currently open sub-menu. */
 			void closeSubMenu();
 
-			/**
-			 * @brief	Closes this sub-menu.
-			 */
+			/**	Closes this sub-menu. */
 			void close();
 
-			/**
-			 * @brief	Returns the type of the displayed drop down menu.
-			 */
+			/**	Returns the type of the displayed drop down menu. */
 			GUIDropDownType getType() const { return mType; }
 
-			/**
-			 * @brief	Returns actual visible bounds of the sub-menu.
-			 */
+			/**	Returns actual visible bounds of the sub-menu. */
 			Rect2I getVisibleBounds() const { return mVisibleBounds; }
 
-			/**
-			 * @brief	Returns the drop box object that owns this sub-menu.
-			 */
+			/**	Returns the drop box object that owns this sub-menu. */
 			GUIDropDownMenu* getOwner() const { return mOwner; }
 
 		public:
@@ -262,24 +212,16 @@ namespace BansheeEngine
 	private:
 		friend class GUIDropDownContent;
 
-		/**
-		 * @brief	Called when the specified sub-menu is opened.
-		 */
+		/**	Called when the specified sub-menu is opened. */
 		void notifySubMenuOpened(DropDownSubMenu* subMenu);
 
-		/**
-		 * @brief	Called when the specified sub-menu is opened.
-		 */
+		/**	Called when the specified sub-menu is opened. */
 		void notifySubMenuClosed(DropDownSubMenu* subMenu);
 
-		/**
-		 * @brief	Called when the drop down box loses focus (and should be closed).
-		 */
+		/**	Called when the drop down box loses focus (and should be closed). */
 		void dropDownFocusLost();
 
-		/**
-		 * @copydoc	GUIWidget::onDestroyed
-		 */
+		/** @copydoc GUIWidget::onDestroyed */
 		void onDestroyed() override;
 
 	private:
@@ -303,4 +245,7 @@ namespace BansheeEngine
 
 		Vector<Rect2I> mAdditionalCaptureBounds;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUIElement.h

@@ -9,16 +9,18 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Implementation
+	 *  @{
+	 */
+
 	/**
-	 * Represents parent class for all visible GUI elements. Contains methods
-	 * needed for positioning, rendering and handling input.
+	 * Represents parent class for all visible GUI elements. Contains methods needed for positioning, rendering and
+	 * handling input.
 	 */
 	class BS_EXPORT GUIElement : public GUIElementBase
 	{
 	public:
-		/**
-		 * @brief	Different sub-types of GUI elements.
-		 */
+		/**	Different sub-types of GUI elements. */
 		enum class ElementType
 		{
 			Label,
@@ -36,45 +38,33 @@ namespace BansheeEngine
 		GUIElement(const String& styleName, const GUIDimensions& dimensions);
 		virtual ~GUIElement();
 
-		/**
-		 * @brief	Sets or removes focus from an element. Will change element style.
-		 */
+		/**	Sets or removes focus from an element. Will change element style. */
 		void setFocus(bool enabled);
 
-		/**
-		 * @brief	Sets the tint of the GUI element.
-		 */
+		/**	Sets the tint of the GUI element. */
 		virtual void setTint(const Color& color);
 
-		/**
-		 * @copydoc	GUIElementBase::resetDimensions
-		 */
+		/** @copydoc GUIElementBase::resetDimensions */
 		virtual void resetDimensions() override;
 
-		/**
-		 * @brief	Sets new style to be used by the element.
-		 */
+		/**	Sets new style to be used by the element. */
 		void setStyle(const String& styleName);
 
-		/**
-		 * @brief	Returns the name of the style used by this element.
-		 */
+		/**	Returns the name of the style used by this element. */
 		const String& getStyleName() const { return mStyleName; }
 
 		/**
-		 * @brief	Assigns a new context menu that will be opened when the element is right clicked.
-		 *			Null is allowed in case no context menu is wanted.
+		 * Assigns a new context menu that will be opened when the element is right clicked. Null is allowed in case no
+		 * context menu is wanted.
 		 */
 		void setContextMenu(const GUIContextMenuPtr& menu) { mContextMenu = menu; }
 
-		/**
-		 * @copydoc	GUIElementBase::getVisibleBounds
-		 */
+		/** @copydoc GUIElementBase::getVisibleBounds */
 		Rect2I getVisibleBounds() override;
 
 		/**
-		 * @brief	Destroy the element. Removes it from parent and widget, and queues
-		 *			it for deletion. Element memory will be released delayed, next frame.
+		 * Destroy the element. Removes it from parent and widget, and queues it for deletion. Element memory will be 
+		 * released delayed, next frame.
 		 */	
 		static void destroy(GUIElement* element);
 
@@ -82,283 +72,190 @@ namespace BansheeEngine
 		/* 							INTERNAL METHODS                      		*/
 		/************************************************************************/
 
+		/** @cond INTERNAL */
+
 		/**
-		 * @brief	Returns the number of separate render elements in the GUI element.
+		 * Returns the number of separate render elements in the GUI element.
 		 * 			
 		 * @return	The number render elements.
 		 *
-		 * @note	Internal method.
-		 *			GUI system attempts to reduce the number of GUI meshes so it will group
-		 * 			sprites based on their material and textures. One render elements represents a group
-		 * 			of such sprites that share a material/texture.
+		 * @note	
+		 * GUI system attempts to reduce the number of GUI meshes so it will group sprites based on their material and 
+		 * textures. One render elements represents a group of such sprites that share a material/texture.
 		 */
 		virtual UINT32 _getNumRenderElements() const = 0;
 
 		/**
-		 * @brief	Gets a material for the specified render element index.
+		 * Gets a material for the specified render element index.
 		 * 		
 		 * @return	Handle to the material.
 		 *
-		 * @see		getNumRenderElements()
-		 *
-		 * @note	Internal method.
+		 * @see		_getNumRenderElements()
 		 */
 		virtual const SpriteMaterialInfo& _getMaterial(UINT32 renderElementIdx) const = 0;
 
 		/**
-		 * @brief	Returns the number of quads that the specified render element will use. You will need this
-		 * 			value when creating the buffers before calling "fillBuffer.
+		 * Returns the number of quads that the specified render element will use. You will need this value when creating
+		 * the buffers before calling _fillBuffer().
 		 * 			
 		 * @return	Number of quads for the specified render element. 
 		 *
-		 * @see		getNumRenderElements()
-		 * @see		fillBuffer()
+		 * @see		_getNumRenderElements()
+		 * @see		_fillBuffer()
 		 * 		
-		 * @note	Internal method.
-		 *			Number of vertices = Number of quads * 4
-		 *			Number of indices = Number of quads * 6	
+		 * @note	
+		 * Number of vertices = Number of quads * 4
+		 * Number of indices = Number of quads * 6	
 		 */
 		virtual UINT32 _getNumQuads(UINT32 renderElementIdx) const = 0;
 
 		/**
-		 * @brief	Fill the pre-allocated vertex, uv and index buffers with the mesh data for the
-		 * 			specified render element.
+		 * Fill the pre-allocated vertex, uv and index buffers with the mesh data for the specified render element.
 		 * 			
-		 * @param	vertices			Previously allocated buffer where to store the vertices.
-		 * @param	uv					Previously allocated buffer where to store the uv coordinates.
-		 * @param	indices				Previously allocated buffer where to store the indices.
-		 * @param	startingQuad		At which quad should the method start filling the buffer.
-		 * @param	maxNumQuads			Total number of quads the buffers were allocated for. Used only
-		 * 								for memory safety.
-		 * @param	vertexStride		Number of bytes between of vertices in the provided vertex and uv data.
-		 * @param	indexStride			Number of bytes between two indexes in the provided index data.
-		 * @param	renderElementIdx	Zero-based index of the render element.
+		 * @param[out]	vertices			Previously allocated buffer where to store the vertices.
+		 * @param[out]	uv					Previously allocated buffer where to store the uv coordinates.
+		 * @param[out]	indices				Previously allocated buffer where to store the indices.
+		 * @param[in]	startingQuad		At which quad should the method start filling the buffer.
+		 * @param[in]	maxNumQuads			Total number of quads the buffers were allocated for. Used only for memory 
+		 *									safety.
+		 * @param[in]	vertexStride		Number of bytes between of vertices in the provided vertex and uv data.
+		 * @param[in]	indexStride			Number of bytes between two indexes in the provided index data.
+		 * @param[in]	renderElementIdx	Zero-based index of the render element.
 		 *
-		 * @see		getNumRenderElements()
-		 * @see		getNumQuads()
-		 *
-		 * @note	Internal method.
+		 * @see		_getNumRenderElements()
+		 * @see		_getNumQuads()
 		 */
 		virtual void _fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
 			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const = 0;
 
 		/**
-		 * @brief	Recreates the internal render elements. Must be called before fillBuffer if element is dirty. 
-		 * 			Marks the element as non dirty.
-		 *
-		 * @note	Internal method.
+		 * Recreates the internal render elements. Must be called before fillBuffer if element is dirty. Marks the element
+		 * as non dirty.
 		 */
 		void _updateRenderElements();
 
-		/**
-		 * @brief	Gets internal element style representing the exact type of GUI element
-		 *			in this object.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Gets internal element style representing the exact type of GUI element in this object. */
 		virtual ElementType _getElementType() const { return ElementType::Undefined; }
 
 		/**
-		 * @brief	Called when a mouse event is received on any GUI element the mouse is interacting
-		 *			with. Return true if you have processed the event and don't want other elements to process it.
-		 *
-		 * @note	Internal method.
+		 * Called when a mouse event is received on any GUI element the mouse is interacting with. Return true if you have
+		 * processed the event and don't want other elements to process it.
 		 */
 		virtual bool _mouseEvent(const GUIMouseEvent& ev);
 
 		/**
-		 * @brief	Called when some text is input and the GUI element has input focus. 
-		 *			Return true if you have processed the event and don't want other elements to process it.
-		 *
-		 * @note	Internal method.
+		 * Called when some text is input and the GUI element has input focus. Return true if you have processed the event
+		 * and don't want other elements to process it.
 		 */	
 		virtual bool _textInputEvent(const GUITextInputEvent& ev);
 
 		/**
-		 * @brief	Called when a command event is triggered. Return true if you have processed the event and 
-		 *			don't want other elements to process it.
-		 *
-		 * @note	Internal method.
+		 * Called when a command event is triggered. Return true if you have processed the event and don't want other 
+		 * elements to process it.
 		 */
 		virtual bool _commandEvent(const GUICommandEvent& ev);
 
 		/**
-		 * @brief	Called when a virtual button is pressed/released and the GUI element has input focus. 
-		 *			Return true if you have processed the event and don't want other elements to process it.
-		 *
-		 * @note	Internal method.
+		 * Called when a virtual button is pressed/released and the GUI element has input focus. Return true if you have
+		 * processed the event and don't want other elements to process it.
 		 */
 		virtual bool _virtualButtonEvent(const GUIVirtualButtonEvent& ev);
 
-		/**
-		 * @brief	Set element part of element depth. Less significant than both
-		 *			widget and area depth.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Set element part of element depth. Less significant than both widget and area depth. */
 		void _setElementDepth(UINT8 depth);
 
-		/**
-		 * @brief	Retrieve element part of element depth. Less significant than both
-		 *			widget and area depth.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Retrieve element part of element depth. Less significant than both widget and area depth. */
 		UINT8 _getElementDepth() const;
 
-		/**
-		 * @copydoc	GUIElementBase::_setLayoutData
-		 */
+		/** @copydoc GUIElementBase::_setLayoutData */
 		virtual void _setLayoutData(const GUILayoutData& data) override;
 
-		/**
-		 * @copydoc	GUIElementBase::_changeParentWidget
-		 */
+		/** @copydoc GUIElementBase::_changeParentWidget */
 		virtual void _changeParentWidget(GUIWidget* widget) override;
 
 		/**
-		 * @brief	Returns depth for a specific render element. This contains a combination
-		 *			of widget depth (8 bit(, area depth (16 bit) and render element depth (8 bit)
-		 *
-		 * @note	Internal method.
+		 * Returns depth for a specific render element. This contains a combination of widget depth (8 bit(, area depth
+		 * (16 bit) and render element depth (8 bit).
 		 *
-		 * @see		getNumRenderElements
+		 * @see		_getNumRenderElements
 		 */
 		virtual UINT32 _getRenderElementDepth(UINT32 renderElementIdx) const { return _getDepth(); }
 
 		/**
-		 * @brief	Returns the range of depths that the child elements can be rendered it.
+		 * Returns the range of depths that the child elements can be rendered it.
 		 *
-		 * @note	e.g. if you are rendering a button with an image and a text you will want the text
-		 *			to be rendered in front of the image at a different depth, which means the depth
-		 *			range is 2 (0 for text, 1 for background image).
+		 * @note	
+		 * e.g. if you are rendering a button with an image and a text you will want the text to be rendered in front of
+		 * the image at a different depth, which means the depth range is 2 (0 for text, 1 for background image).
 		 */
 		virtual UINT32 _getRenderElementDepthRange() const { return 1; }
 
-		/**
-		 * @brief	Gets internal element style representing the exact type of GUI element
-		 *			in this object.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Gets internal element style representing the exact type of GUI element in this object. */
 		Type _getType() const override { return GUIElementBase::Type::Element; }
 
-		/**
-		 * @brief	Checks if element has been destroyed and is queued for deletion.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Checks if element has been destroyed and is queued for deletion. */
 		bool _isDestroyed() const override { return mIsDestroyed; }
 
-		/**
-		 * @brief	Update element style based on active GUI skin and style name.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Update element style based on active GUI skin and style name. */
 		void _refreshStyle();
 
-		/**
-		 * @brief	Gets the currently active element style.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Gets the currently active element style. */
 		const GUIElementStyle* _getStyle() const { return mStyle; }
 
-		/**
-		 * @brief	Gets GUI element bounds relative to parent widget, clipped by specified clip rect.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Gets GUI element bounds relative to parent widget, clipped by specified clip rect. */
 		const Rect2I& _getClippedBounds() const { return mClippedBounds; }
 
-		/**
-		 * @brief	Returns GUI element padding. Padding is modified by changing element style and determines
-		 *			minimum distance between different GUI elements.
-		 *
-		 * @note	Internal method.
+		/** 
+		 * Returns GUI element padding. Padding is modified by changing element style and determines minimum distance 
+		 * between different GUI elements. 
 		 */
 		const RectOffset& _getPadding() const override;
 
 		/**
-		 * @brief	Returns GUI element depth. This includes widget and area depth, but does not
-		 *			include specific per-render-element depth.
-		 *
-		 * @note	Internal method.
+		 * Returns GUI element depth. This includes widget and area depth, but does not include specific per-render-element
+		 * depth.
 		 */
 		UINT32 _getDepth() const { return mLayoutData.depth; }
 
-		/**
-		 * @brief	Checks is the specified position within GUI element bounds. Position is relative to
-		 *			parent GUI widget.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Checks is the specified position within GUI element bounds. Position is relative to parent GUI widget. */
 		virtual bool _isInBounds(const Vector2I position) const;
 
-		/**
-		 * @brief	Checks if the GUI element has a custom cursor and outputs the cursor type if it does.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Checks if the GUI element has a custom cursor and outputs the cursor type if it does. */
 		virtual bool _hasCustomCursor(const Vector2I position, CursorType& type) const { return false; }
 
-		/**
-		 * @brief	Checks if the GUI element accepts a drag and drop operation of the specified type.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Checks if the GUI element accepts a drag and drop operation of the specified type. */
 		virtual bool _acceptDragAndDrop(const Vector2I position, UINT32 typeId) const { return false; }
 
-		/**
-		 * @brief	Returns a context menu if a GUI element has one. Otherwise returns nullptr.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns a context menu if a GUI element has one. Otherwise returns nullptr. */
 		virtual GUIContextMenuPtr _getContextMenu() const;
 
-		/**
-		 * @brief	Returns text to display when hovering over the element. Returns empty string if no tooltip.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns text to display when hovering over the element. Returns empty string if no tooltip. */
 		virtual WString _getTooltip() const { return StringUtil::WBLANK; }
 
-		/**
-		 * @brief	Returns a clip rectangle relative to the element, used for offsetting
-		 * 			the input text.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns a clip rectangle relative to the element, used for offsetting the input text. */
 		virtual Vector2I _getTextInputOffset() const { return Vector2I(); }
 
-		/**
-		 * @brief	Returns a clip rectangle relative to the element, used for clipping
-		 * 			the input text.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns a clip rectangle relative to the element, used for clipping	the input text. */
 		virtual Rect2I _getTextInputRect() const { return Rect2I(); }
 
-		/**
-		 * @brief	Triggered when the element loses or gains focus.
-		 */
+		/** @endcond */
+
+		/**	Triggered when the element loses or gains focus. */
 		Event<void(bool)> onFocusChanged;
 
 	protected:
-		/**
-		 * @brief	Called whenever render elements are dirty and need to be rebuilt.
-		 */
+		/**	Called whenever render elements are dirty and need to be rebuilt. */
 		virtual void updateRenderElementsInternal();
 
 		/**
-		 * @brief	Called whenever element clipped bounds need to be recalculated. (e.g. when
-		 *			width, height or clip rectangles changes).
+		 * Called whenever element clipped bounds need to be recalculated. (e.g. when width, height or clip rectangles 
+		 * changes).
 		 */
 		virtual void updateClippedBounds();
 
 		/**
-		 * @brief	Helper method that returns style name used by an element of a certain type.
-		 *			If override style is empty, default style for that type is returned.
+		 * Helper method that returns style name used by an element of a certain type. If override style is empty, default
+		 * style for that type is returned.
 		 */
 		template<class T>
 		static const String& getStyleName(const String& overrideStyle)
@@ -370,35 +267,27 @@ namespace BansheeEngine
 		}
 
 		/**
-		 * @brief	Attempts to find a sub-style for the specified type in the currently
-		 *			set GUI element style. If one cannot be found empty string is returned.
+		 * Attempts to find a sub-style for the specified type in the currently set GUI element style. If one cannot be
+		 * found empty string is returned.
 		 */
 		const String& getSubStyleName(const String& subStyleTypeName) const;
 
-		/**
-		 * @brief	Method that gets triggered whenever element style changes.
-		 */
+		/**	Method that gets triggered whenever element style changes. */
 		virtual void styleUpdated() { }
 
-		/**
-		 * @brief	Returns clipped bounds excluding the margins. Relative to parent widget.
-		 */
+		/**	Returns clipped bounds excluding the margins. Relative to parent widget. */
 		Rect2I getCachedVisibleBounds() const;
 
-		/**
-		 * @brief	Returns bounds of the content contained within the GUI element. Relative to parent widget.
-		 */
+		/**	Returns bounds of the content contained within the GUI element. Relative to parent widget. */
 		Rect2I getCachedContentBounds() const;
 
 		/**
-		 * @brief	Returns a clip rectangle that can be used for clipping the contents of this
-		 *			GUI element. Clip rect is relative to GUI element origin.
+		 * Returns a clip rectangle that can be used for clipping the contents of this GUI element. Clip rect is relative
+		 * to GUI element origin.
 		 */
 		Rect2I getCachedContentClipRect() const;
 
-		/**
-		 * @brief	Returns the tint that is applied to the GUI element.
-		 */
+		/**	Returns the tint that is applied to the GUI element. */
 		Color getTint() const;
 
 		bool mIsDestroyed;
@@ -413,4 +302,6 @@ namespace BansheeEngine
 		GUIContextMenuPtr mContextMenu;
 		Color mColor;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIElementBase.h

@@ -9,15 +9,15 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Base class for all GUI elements (visible or layout).
+	/** @addtogroup Implementation
+	 *  @{
 	 */
+
+	/**	Base class for all GUI elements (visible or layout). */
 	class BS_EXPORT GUIElementBase
 	{
 	public:
-		/**
-		 * @brief	Valid types of GUI base elements.
-		 */
+		/**	Valid types of GUI base elements. */
 		enum class Type
 		{
 			Layout,
@@ -28,9 +28,7 @@ namespace BansheeEngine
 		};
 
 	protected:
-		/**
-		 * @brief	Flags that signal the state of the GUI element.
-		 */
+		/**	Flags that signal the state of the GUI element. */
 		enum GUIElementFlags
 		{
 			GUIElem_Dirty = 0x01,
@@ -48,88 +46,80 @@ namespace BansheeEngine
 		virtual ~GUIElementBase();
 
 		/**
-		 * @brief	Sets element position relative to parent GUI panel.
+		 * Sets element position relative to parent GUI panel.
 		 *
-		 * @note	Be aware that this value will be ignored if GUI element is part of a layout since then
-		 *			the layout controls its placement.
+		 * @note	
+		 * Be aware that this value will be ignored if GUI element is part of a layout since then the layout controls its
+		 * placement.
 		 */
 		void setPosition(INT32 x, INT32 y);
 
-		/**
-		 * @brief	Sets element width in pixels. 
-		 */
+		/**	Sets element width in pixels.  */
 		void setWidth(UINT32 width);
 
 		/**
-		 * @brief	Sets element width in pixels. Element will be resized according to its 
-		 *			contents and parent layout but will always stay within the provided range.
-		 *			If maximum width is zero, the element is allowed to expand as much as it needs.
+		 * Sets element width in pixels. Element will be resized according to its contents and parent layout but will 
+		 * always stay within the provided range. If maximum width is zero, the element is allowed to expand as much as
+		 * it needs.
 		 */
 		void setFlexibleWidth(UINT32 minWidth = 0, UINT32 maxWidth = 0);
 
-		/**
-		 * @brief	Sets element height in pixels.
-		 */
+		/**	Sets element height in pixels. */
 		void setHeight(UINT32 height);
 
 		/**
-		 * @brief	Sets element height in pixels. Element will be resized according to its 
-		 *			contents and parent layout but will always stay within the provided range.
-		 *			If maximum height is zero, the element is allowed to expand as much as it needs.
+		 * Sets element height in pixels. Element will be resized according to its contents and parent layout but will 
+		 * always stay within the provided range. If maximum height is zero, the element is allowed to expand as much as
+		 * it needs.
 		 */
 		void setFlexibleHeight(UINT32 minHeight = 0, UINT32 maxHeight = 0);
 
-		/**
-		 * @brief	Resets element dimensions to their initial values dictated by the element's style.
-		 */
+		/**	Resets element dimensions to their initial values dictated by the element's style. */
 		virtual void resetDimensions();
 
 		/**
-		 * @brief	Hides or shows this element and recursively applies the same state to all the child elements.
-		 * 			This will not remove the element from the layout, the room for it will still be reserved but it just
-		 * 			won't be visible.
+		 * Hides or shows this element and recursively applies the same state to all the child elements. This will not
+		 * remove the element from the layout, the room for it will still be reserved but it just won't be visible.
 		 */
 		void setVisible(bool visible);
 
 		/**
-		 * @brief	Activates or deactives this element and recursively applies the same state to all the child elements.
-		 * 			This has the same effect as ::setVisible, but when disabled it will also remove the element from the 
-		 * 			layout, essentially having the same effect is if you destroyed the element.
+		 * Activates or deactives this element and recursively applies the same state to all the child elements. This has 
+		 * the same effect as setVisible(), but when disabled it will also remove the element from the layout, essentially
+		 * having the same effect is if you destroyed the element.
 		 */
 		void setActive(bool active);
 
-		/**
-		 * @brief	Disables or enables the element. Disabled elements cannot be interacted with and have a faded out 
-		 *			appearance.
-		 */
+		/** Disables or enables the element. Disabled elements cannot be interacted with and have a faded out appearance. */
 		void setDisabled(bool disabled);
 
 		/**
-		 * @brief	Returns non-clipped bounds of the GUI element. Relative to a parent GUI panel.
+		 * Returns non-clipped bounds of the GUI element. Relative to a parent GUI panel.
 		 *
-		 * @param	relativeTo	Parent panel of the provided element relative to which to return the
-		 *						bounds. If null the bounds relative to the first parent panel are returned.
-		 *						Behavior is undefined if provided panel is not a parent of the element.
+		 * @param[in]	relativeTo	Parent panel of the provided element relative to which to return the bounds. If null 
+		 *							the bounds relative to the first parent panel are returned. Behavior is undefined if 
+		 *							provided panel is not a parent of the element.
 		 *
 		 * @note	This call can be potentially expensive if the GUI state is dirty.
 		 */
 		Rect2I getBounds(GUIPanel* relativeTo = nullptr);
 
 		/**
-		 * @brief	Sets the bounds of the GUI element. Relative to a parent GUI panel.
-		 * 			Equivalent to calling setPosition, setWidth and setHeight.
+		 * Sets the bounds of the GUI element. Relative to a parent GUI panel. Equivalent to calling setPosition(), 
+		 * setWidth() and setHeight().
 		 */
 		void setBounds(const Rect2I& bounds);
 
 		/**
-		 * @brief	Returns non-clipped bounds of the GUI element. Relative to a parent GUI widget.
+		 * Returns non-clipped bounds of the GUI element. Relative to a parent GUI widget.
 		 *
 		 * @note	This call can be potentially expensive if the GUI state is dirty.
 		 */
 		Rect2I getGlobalBounds();
 
 		/**
-		 * @brief	Returns non-clipped visible bounds of the GUI element (bounds exclude the margins). Relative to the parent GUI panel.
+		 * Returns non-clipped visible bounds of the GUI element (bounds exclude the margins). Relative to the parent GUI 
+		 * panel.
 		 *
 		 * @note	This call can be potentially expensive as the bounds need to be calculated based on current GUI state.
 		 */
@@ -139,179 +129,109 @@ namespace BansheeEngine
 		/* 							INTERNAL METHODS                      		*/
 		/************************************************************************/
 
+		/** @cond INTERNAL */
+
 		/**
-		 * @brief	Updates child elements positions, sizes, clip rectangles and depths so they
-		 *			fit into the provided bounds, while respecting their layout options. 
+		 * Updates child elements positions, sizes, clip rectangles and depths so they fit into the provided bounds, while
+		 * respecting their layout options. 
 		 *
-		 * @param	data	Layout data containing the necessary bounds and restrictions
-		 *					to use for calculating the child element layout data.
+		 * @param[in]	data	Layout data containing the necessary bounds and restrictions to use for calculating the 
+		 *						child element layout data.
 		 *
 		 * @note	Internal method.
 		 */
 		virtual void _updateLayout(const GUILayoutData& data);
 
-		/**
-		 * @brief	Calculates optimal sizes of all child elements, as determined by their style and layout options.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Calculates optimal sizes of all child elements, as determined by their style and layout options. */
 		virtual void _updateOptimalLayoutSizes();
 
-		/**
-		 * @copydoc	_updateLayout
-		 *
-		 * @note	Internal method.
-		 */
+		/** @copydoc _updateLayout */
 		virtual void _updateLayoutInternal(const GUILayoutData& data);
 
 		/**
-		 * @brief	Calculates positions & sizes of all elements in the layout. This method expects a pre-allocated array to store the data in.
+		 * Calculates positions & sizes of all elements in the layout. This method expects a pre-allocated array to store 
+		 * the data in.
 		 *
-		 * @brief	layoutArea		Parent layout area to position the child elements in.
-		 * @param	elementAreas	Array to hold output areas. Must be the same size as the number of child elements.
-		 * @param	numElements		Size of the element areas array.
-		 * @param	sizeRanges		Ranges of possible sizes used for the child elements. Array must be same size as elements array.
-		 * @param	mySizeRange		Size range of this element.
+		 * @param[in]	layoutArea		Parent layout area to position the child elements in.
+		 * @param[out]	elementAreas	Array to hold output areas. Must be the same size as the number of child elements.
+		 * @param[in]	numElements		Size of the element areas array.
+		 * @param[in]	sizeRanges		Ranges of possible sizes used for the child elements. Array must be same size as 
+		 *								elements array.
+		 * @param[in]	mySizeRange		Size range of this element.
 		 */
 		virtual void _getElementAreas(const Rect2I& layoutArea, Rect2I* elementAreas, UINT32 numElements,
 			const Vector<LayoutSizeRange>& sizeRanges, const LayoutSizeRange& mySizeRange) const;
 
-		/**
-		 * @brief	Updates layout data that determines GUI elements final position & depth 
-		 *			in the GUI widget.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Updates layout data that determines GUI elements final position & depth in the GUI widget. */
 		virtual void _setLayoutData(const GUILayoutData& data) { mLayoutData = data; }
 
-		/**
-		 * @brief	Retrieves layout data that determines GUI elements final position & depth
-		 *			in the GUI widget.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Retrieves layout data that determines GUI elements final position & depth in the GUI widget. */
 		const GUILayoutData& _getLayoutData() const { return mLayoutData; }
 
-		/**
-		 * @brief	Sets a new parent for this element.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Sets a new parent for this element. */
 		void _setParent(GUIElementBase* parent);
 
-		/**
-		 * @brief	Returns number of child elements.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns number of child elements. */
 		UINT32 _getNumChildren() const { return (UINT32)mChildren.size(); }
 
-		/**
-		 * @brief	Return the child element at the specified index.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Return the child element at the specified index.*/
 		GUIElementBase* _getChild(UINT32 idx) const { return mChildren[idx]; }
 
-		/**
-		 * @brief	Returns previously calculated optimal size for this element.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns previously calculated optimal size for this element. */
 		virtual Vector2I _getOptimalSize() const = 0;
 
-		/**
-		 * @brief	Returns layout options that determine how is the element positioned and sized.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns layout options that determine how is the element positioned and sized. */
 		const GUIDimensions& _getDimensions() const { return mDimensions; }
 
-		/**
-		 * @brief	Calculates element size range constrained by its layout options.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Calculates element size range constrained by its layout options. */
 		virtual LayoutSizeRange _calculateLayoutSizeRange() const ;
 
 		/**
-		 * @brief	Returns element size range constrained by its layout options. This is
-		 *			different from ::_calculateLayoutSizeRange because this method may return
-		 *			cached size range.
-		 *
-		 * @note	Internal method.
+		 * Returns element size range constrained by its layout options. This is different from _calculateLayoutSizeRange()
+		 * because this method may return cached size range. 
 		 */
 		virtual LayoutSizeRange _getLayoutSizeRange() const;
 
 		/**
-		 * @brief	Returns element padding that determines how far apart to space out this element
-		 *			from other elements in a layout.
-		 *
-		 * @note	Internal method.
+		 * Returns element padding that determines how far apart to space out this element from other elements in a layout.
 		 */
 		virtual const RectOffset& _getPadding() const = 0;
 
-		/**
-		 * @brief	Returns specific sub-type of this object.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns specific sub-type of this object. */
 		virtual Type _getType() const = 0;
 
-		/**
-		 * @brief	Returns parent GUI base element.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns parent GUI base element. */
 		GUIElementBase* _getParent() const { return mParentElement; }
 
 		/**
-		 * @brief	Returns the parent element whose layout needs to be updated 
-		 *			when this elements contents change.
+		 * Returns the parent element whose layout needs to be updated when this elements contents change.
 		 *
-		 * @note	Due to the nature of the GUI system, when a child element bounds
-		 *			or contents change, its parents and siblings usually need their
-		 *			layout bound updated. This function returns the first parent of 
-		 *			all the elements that require updating. This parent usually
-		 *			has fixed bounds or some other property that allows its children
-		 *			to be updated independently from the even higher-up elements.
+		 * @note	
+		 * Due to the nature of the GUI system, when a child element bounds or contents change, its parents and siblings
+		 * usually need their layout bound updated. This function returns the first parent of all the elements that require
+		 * updating. This parent usually has fixed bounds or some other property that allows its children to be updated
+		 * independently from the even higher-up elements.
 		 */
 		GUIElementBase* _getUpdateParent() const { return mUpdateParent; }
 
-		/**
-		 * @brief	Returns parent GUI widget, can be null.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns parent GUI widget, can be null. */
 		GUIWidget* _getParentWidget() const { return mParentWidget; }
 
-		/**
-		 * @brief	Checks if element is visible or hidden.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Checks if element is visible or hidden. */
 		bool _isVisible() const { return (mFlags & GUIElem_Hidden) == 0; }
 
 		/**
-		 * @brief	Checks if element is active or inactive. Inactive elements are not visible, don't take up space
-		 *			in their parent layouts, and can't be interacted with.
-		 *
-		 * @note	Internal method.
+		 * Checks if element is active or inactive. Inactive elements are not visible, don't take up space
+		 * in their parent layouts, and can't be interacted with. 
 		 */
 		bool _isActive() const { return (mFlags & GUIElem_Inactive) == 0; }
 
-		/**
-		 * @brief	Checks if element is disabled. Disabled elements cannot be interacted with and have a faded out appearance.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Checks if element is disabled. Disabled elements cannot be interacted with and have a faded out appearance. */
 		bool _isDisabled() const { return (mFlags & GUIElem_Disabled) != 0; }
 
 		/**
-		 * Internal version of ::setVisible that doesn't modify local visibility, instead it is only meant to be called
+		 * Internal version of setVisible() that doesn't modify local visibility, instead it is only meant to be called
 		 * on child elements of the element whose visibility was modified.
-		 *  
-		 * @copydoc setVisible
 		 */
 		void _setVisible(bool visible);
 
@@ -332,103 +252,67 @@ namespace BansheeEngine
 		void _setDisabled(bool disabled);
 
 		/**
-		 * @brief	Changes the active GUI element widget. This allows you to move an element
-		 *			to a different viewport, or change element style by using a widget with a different skin.
-		 *			You are allowed to pass null here, but elements with no parent will be unmanaged. You will be
-		 *			responsible for deleting them manually, and they will not render anywhere.
-		 *
-		 * @note	Internal method.
+		 * Changes the active GUI element widget. This allows you to move an element to a different viewport, or change
+		 * element style by using a widget with a different skin. You are allowed to pass null here, but elements with no
+		 * parent will be unmanaged. You will be responsible for deleting them manually, and they will not render anywhere.
 		 */
 		virtual void _changeParentWidget(GUIWidget* widget);
 
-		/**
-		 * @brief	Registers a new child element.
-		 *
-		 * @note	Internal method.
-		 */
+		/**Registers a new child element. */
 		void _registerChildElement(GUIElementBase* element);
 
-		/**
-		 * @brief	Unregisters an existing child element.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Unregisters an existing child element. */
 		void _unregisterChildElement(GUIElementBase* element);
 
-		/**
-		 * @brief	Checks if element has been destroyed and is queued for deletion.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Checks if element has been destroyed and is queued for deletion. */
 		virtual bool _isDestroyed() const { return false; }
 
-		/**
-		 * @brief	Marks the element's dimensions as dirty, triggering a layout rebuild.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Marks the element's dimensions as dirty, triggering a layout rebuild. */
 		void _markLayoutAsDirty();
 
-		/**
-		 * @brief	Marks the element's contents as dirty, which causes the sprite meshes to be recreated from scratch.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Marks the element's contents as dirty, which causes the sprite meshes to be recreated from scratch. */
 		void _markContentAsDirty();
 
 		/**
-		 * @brief	Mark only the elements that operate directly on the sprite mesh without requiring the mesh
-		 * 			to be recreated as dirty. This includes position, depth and clip rectangle. This will cause
-		 *			the parent widget mesh to be rebuilt from its child element's meshes.
-		 *
-		 * @note	Internal method.
+		 * Mark only the elements that operate directly on the sprite mesh without requiring the mesh to be recreated as 
+		 * dirty. This includes position, depth and clip rectangle. This will cause the parent widget mesh to be rebuilt
+		 * from its child element's meshes.
 		 */
 		void _markMeshAsDirty();
 
-		/**
-		 * @brief	Returns true if elements contents have changed since last update.
-		 */
+		/**	Returns true if elements contents have changed since last update. */
 		bool _isDirty() const { return (mFlags & GUIElem_Dirty) != 0; }
 
-		/**
-		 * @brief	Marks the element contents to be up to date. (i.e. processed by the GUI system)
-		 */
+		/**	Marks the element contents to be up to date. (i.e. processed by the GUI system) */
 		void _markAsClean();
 
+		/** @endcond */
+
 	protected:
-		/**
-		 * @brief	Finds anchor and update parents and recursively assigns them to all children.
-		 */
+		/**	Finds anchor and update parents and recursively assigns them to all children. */
 		void _updateAUParents();
 
-		/**
-		 * @brief	Refreshes update parents of all child elements.
-		 */
+		/**	Refreshes update parents of all child elements. */
 		void refreshChildUpdateParents();
 
 		/**
-		 * @brief	Finds the first parent element whose size doesn't depend on child sizes.
+		 * Finds the first parent element whose size doesn't depend on child sizes.
 		 *			
-		 * @note	This allows us to optimize layout updates and trigger them only on such parents
-		 *			when their child elements contents change, compared to doing them on the entire
-		 *			GUI hierarchy.
+		 * @note	
+		 * This allows us to optimize layout updates and trigger them only on such parents when their child elements 
+		 * contents change, compared to doing them on the entire GUI hierarchy.
 		 */
 		GUIElementBase* findUpdateParent();
 
 		/**
-		 * @brief	Helper method for recursion in "_updateAUParents". Sets the provided anchor 
-		 *			parent for all children recursively. Recursion stops when a child anchor is detected.
-		 *
-		 * @see	_updateParents
+		 * Helper method for recursion in _updateAUParents(). Sets the provided anchor parent for all children recursively.
+		 * Recursion stops when a child anchor is detected.
 		 */
 		void setAnchorParent(GUIPanel* anchorParent);
 
 		/**
-		 * @brief	Helper method for recursion in "_updateAUParents". Sets the provided update 
-		 *			parent for all children recursively. Recursion stops when a child update parent
-		 *			is detected.
-		 *
-		 * @see	_updateParents
+		 * Helper method for recursion in _updateAUParents(). Sets the provided update parent for all children recursively.
+		 * Recursion stops when a child update parent is detected.
 		 */
 		void setUpdateParent(GUIElementBase* updateParent);
 
@@ -443,4 +327,6 @@ namespace BansheeEngine
 		GUIDimensions mDimensions;
 		GUILayoutData mLayoutData;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsImageSprite.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Image sprite description structure used for initializing or updating an image sprite.
+	/** @cond INTERNAL */
+	/** @addtogroup 2D
+	 *  @{
 	 */
+
+	/**	Image sprite description structure used for initializing or updating an image sprite. */
 	struct IMAGE_SPRITE_DESC
 	{
 		IMAGE_SPRITE_DESC()
@@ -27,18 +30,14 @@ namespace BansheeEngine
 		SpriteTexturePtr texture; /**< Texture to overlay on the sprite. */
 		Color color; /**< Color tint to apply to the sprite. */
 
-		/** Borders (in texels) that allow you to control how is the texture scaled. 
-		 * If borders are 0 the texture will be scaled uniformly. If they are not null
-		 * only the area inside the borders will be scaled and the outside are will remain
-		 * the original size as in the texture. This allows you to implement "Scale9Grid"
-		 * functionality.
+		/** Borders (in texels) that allow you to control how is the texture scaled. If borders are 0 the texture will be 
+		 * scaled uniformly. If they are not null only the area inside the borders will be scaled and the outside are will
+		 * remain the original size as in the texture. This allows you to implement "Scale9Grid" functionality.
 		 */
 		UINT32 borderLeft, borderRight, borderTop, borderBottom; 
 	};
 
-	/**
-	 * @brief	A sprite consisting of a single image represented by a sprite texture.
-	 */
+	/**	A sprite consisting of a single image represented by a sprite texture. */
 	class BS_EXPORT ImageSprite : public Sprite
 	{
 	public:
@@ -46,19 +45,20 @@ namespace BansheeEngine
 		~ImageSprite();
 
 		/**
-		 * @brief	Recreates internal sprite data according the specified description structure.
+		 * Recreates internal sprite data according the specified description structure.
 		 *
-		 * @param	desc	Describes the geometry and material of the sprite.
-		 * @param	groupId	Group identifier that forces different materials to be used for
-		 *					different groups (e.g. you don't want the sprites to
-		 *					share the same material if they use different world transform matrices)
+		 * @param[in]	desc	Describes the geometry and material of the sprite.
+		 * @param[in]	groupId	Group identifier that forces different materials to be used for different groups (e.g. you
+		 *						don't want the sprites to share the same material if they use different world transform 
+		 *						matrices).
 		 */
 		void update(const IMAGE_SPRITE_DESC& desc, UINT64 groupId);
 
 	private:
-		/**
-		 * @brief	Clears internal geometry buffers.
-		 */
+		/**	Clears internal geometry buffers. */
 		void clearMesh();
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsPrerequisites.h

@@ -14,6 +14,42 @@
   * specialized functionality than Renderer abstraction in BansheeCore.
   */
 
+/** @defgroup 2D 2D
+  *	Functionality relating to two dimensional geometry like sprites.
+  */
+
+/** @defgroup Components Components
+  *	Built-in components (elements that may be attached to scene objects).
+  */
+
+/** @defgroup GUI GUI
+  *	Everything relating to the graphical user interface, including elements, styles, events and GUI manager.
+  */
+
+/** @defgroup Input-Engine Input
+ *	Functionality for dealing with input (mouse, keyboard, gamepad, etc.).
+ */
+
+/** @defgroup RTTI-Impl-Engine RTTI types
+ *  Types containing RTTI for specific classes.
+ */
+
+/** @defgroup Resources Resources
+  *	Contains engine resource types and manager for builtin resources.
+  */
+
+/** @defgroup Utility-Engine Utility
+ *  Various utility methods and types used by the engine layer.
+ */
+
+/** @defgroup Platform-Engine Platform
+ *  Platform specific functionality.
+ */
+
+/** @defgroup Application-Engine Application
+ *  Entry point into the application.
+ */
+
 /** @} */
 
 #if (BS_PLATFORM == BS_PLATFORM_WIN32) && !defined(__MINGW32__)

BansheeEngine/Include/BsSprite.h

@@ -7,6 +7,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup 2D
+	 *  @{
+	 */
+
 	/** Determines position of the sprite in its bounds. */
 	enum SpriteAnchor
 	{
@@ -39,8 +44,6 @@ namespace BansheeEngine
 		Color tint;
 	};
 
-	/** @cond INTERNAL */
-
 	/** Equals operator for SpriteMaterialInfo. */
 	bool operator==(const SpriteMaterialInfo& lhs, const SpriteMaterialInfo& rhs);
 
@@ -61,12 +64,7 @@ namespace BansheeEngine
 		SpriteMaterialInfo matInfo;
 	};
 
-	/** @endcond */
-
-	/**
-	 * @brief	Generates geometry and contains information needed for rendering
-	 *			a two dimensional element.
-	 */
+	/**	Generates geometry and contains information needed for rendering a two dimensional element. */
 	class BS_EXPORT Sprite
 	{
 	public:
@@ -74,27 +72,26 @@ namespace BansheeEngine
 		virtual ~Sprite();
 
 		/**
-		 * @brief	Returns clipped bounds of the sprite.
+		 * Returns clipped bounds of the sprite.
 		 *
-		 * @param	offset		Offset that will be added to the returned bounds.
-		 * @param	clipRect	Local clip rect that is used for clipping the sprite bounds.
-		 *						(Clipping is done before the offset is applied). If clip rect
-		 *						width or height is zero, no clipping is done.
+		 * @param[in]	offset		Offset that will be added to the returned bounds.
+		 * @param[in]	clipRect	Local clip rect that is used for clipping the sprite bounds. (Clipping is done before 
+		 *							the offset is applied). If clip rect width or height is zero, no clipping is done.
 		 *
-		 * @returns	Clipped sprite bounds.
+		 * @return				Clipped sprite bounds.
 		 */
 		Rect2I getBounds(const Vector2I& offset, const Rect2I& clipRect) const;
 
 		/**
-		 * @brief	Returns the number of separate render elements in the sprite. Normally this is 1, but some sprites
-		 * 			may consist of multiple materials, in which case each will require its own mesh (render element)
+		 * Returns the number of separate render elements in the sprite. Normally this is 1, but some sprites may consist 
+		 * of multiple materials, in which case each will require its own mesh (render element)
 		 * 			
 		 * @return	The number render elements.
 		 */
 		UINT32 getNumRenderElements() const;
 
 		/**
-		 * @brief	Gets a material for the specified render element index.
+		 * Gets a material for the specified render element index.
 		 * 		
 		 * @return	Structure describing the material.
 		 *
@@ -103,8 +100,8 @@ namespace BansheeEngine
 		const SpriteMaterialInfo& getMaterialInfo(UINT32 renderElementIdx) const;
 
 		/**
-		 * @brief	Returns the number of quads that the specified render element will use. You will need this
-		 * 			value when creating the buffers before calling "fillBuffer".
+		 * Returns the number of quads that the specified render element will use. You will need this value when creating
+		 * the buffers before calling fillBuffer().
 		 * 			
 		 * @return	Number of quads for the specified render element. 
 		 *	
@@ -117,51 +114,51 @@ namespace BansheeEngine
 		UINT32 getNumQuads(UINT32 renderElementIdx) const;
 
 		/**
-		 * @brief	Fill the pre-allocated vertex, uv and index buffers with the mesh data for the
-		 * 			specified render element.
+		 * Fill the pre-allocated vertex, uv and index buffers with the mesh data for the specified render element.
 		 *
-		 * @param	vertices			Previously allocated buffer where to store the vertices.
-		 * @param	uv					Previously allocated buffer where to store the uv coordinates.
-		 * @param	indices				Previously allocated buffer where to store the indices.
-		 * @param	startingQuad		At which quad should the method start filling the buffer.
-		 * @param	maxNumQuads			Total number of quads the buffers were allocated for. Used only
-		 * 								for memory safety.
-		 * @param	vertexStride		Number of bytes between of vertices in the provided vertex and uv data.
-		 * @param	indexStride			Number of bytes between two indexes in the provided index data.
-		 * @param	renderElementIdx	Zero-based index of the render element.
+		 * @param[out]	vertices			Previously allocated buffer where to store the vertices.
+		 * @param[out]	uv					Previously allocated buffer where to store the uv coordinates.
+		 * @param[out]	indices				Previously allocated buffer where to store the indices.
+		 * @param[in]	startingQuad		At which quad should the method start filling the buffer.
+		 * @param[in]	maxNumQuads			Total number of quads the buffers were allocated for. Used only for memory 
+		 *									safety.
+		 * @param[in]	vertexStride		Number of bytes between of vertices in the provided vertex and uv data.
+		 * @param[in]	indexStride			Number of bytes between two indexes in the provided index data.
+		 * @param[in]	renderElementIdx	Zero-based index of the render element.
 		 *
 		 * @see		getNumRenderElements()
 		 * @see		getNumQuads()
 		 */
 		UINT32 fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, UINT32 maxNumQuads, 
-			UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx, const Vector2I& offset, const Rect2I& clipRect, bool clip = true) const;
+			UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx, const Vector2I& offset, 
+			const Rect2I& clipRect, bool clip = true) const;
 
 	protected:
 		/**
-		 * @brief	Clips the provided vertices to the provided clip rectangle.
+		 * Clips the provided vertices to the provided clip rectangle.
 		 *
-		 * @param	vertices	Pointer to the start of the buffer containing vertex positions.
-		 * @param	uv			Pointer to the start of the buffer containing UV coordinates.
-		 * @param	numQuads	Number of quads in the provided buffer pointers.
-		 * @param	vertStride	Number of bytes to skip when going to the next vertex. This assumes both position
-		 *						and uv coordinates have the same stride (as they are likely pointing to the same buffer).
-		 * @param	clipRect	Rectangle to clip the geometry to.
+		 * @param[in, out]	vertices	Pointer to the start of the buffer containing vertex positions.
+		 * @param[in, out]	uv			Pointer to the start of the buffer containing UV coordinates.
+		 * @param[in]		numQuads	Number of quads in the provided buffer pointers.
+		 * @param[in]		vertStride	Number of bytes to skip when going to the next vertex. This assumes both position
+		 *								and uv coordinates have the same stride (as they are likely pointing to the same 
+		 *								buffer).
+		 * @param[in]		clipRect	Rectangle to clip the geometry to.
 		 */
 		static void clipToRect(UINT8* vertices, UINT8* uv, UINT32 numQuads, UINT32 vertStride, const Rect2I& clipRect);
 
-		/**
-		 * @brief	Returns the offset needed to move the sprite in order for it to respect the provided anchor.
-		 */
+		/**	Returns the offset needed to move the sprite in order for it to respect the provided anchor. */
 		static Vector2I getAnchorOffset(SpriteAnchor anchor, UINT32 width, UINT32 height);
 
-		/**
-		 * @brief	Calculates the bounds of all sprite vertices.
-		 */
+		/**	Calculates the bounds of all sprite vertices. */
 		void updateBounds() const;
 
 		mutable Rect2I mBounds;
 		mutable Vector<SpriteRenderElement> mCachedRenderElements;
 	};
+
+	/** @} */
+	/** @endcond */
 }
 
 /** @cond STDLIB */

BansheeEngine/Include/BsSpriteTexture.h

@@ -6,105 +6,81 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup 2D
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Texture interface that encapsulates underlying texture which allows us
-	 * 			to create a sprite texture atlas (e.g. multiple SpriteTexture%s referencing
-	 *			different parts of a single Texture).
+	 * Texture interface that encapsulates underlying texture which allows us to create a sprite texture atlas (e.g. 
+	 * multiple SpriteTexture%s referencing different parts of a single Texture).
 	 */
 	class BS_EXPORT SpriteTexture : public Resource
 	{
 	public:
-		/**
-		 * @brief	Gets the internal texture that the sprite texture references.
-		 */
+		/**	Gets the internal texture that the sprite texture references. */
 		const HTexture& getTexture() const;
 
-		/**
-		 * @brief	Sets the internal texture that the sprite texture references.
-		 */
+		/**	Sets the internal texture that the sprite texture references. */
 		void setTexture(const HTexture& texture);
 
 		/**
-		 * @brief	Gets the offset into the referenced texture where the sprite starts.
+		 * Gets the offset into the referenced texture where the sprite starts.
 		 *
 		 * @return	Offset in UV coordinates, range [0, 1].
 		 */
 		Vector2 getOffset() const { return mUVOffset; }
 
 		/**
-		 * @brief	Sets the offset into the referenced texture where the sprite starts.
+		 * Sets the offset into the referenced texture where the sprite starts.
 		 *
 		 * @param	offset	Offset in UV coordinates, range [0, 1].
 		 */
 		void setOffset(const Vector2& offset) { mUVOffset = offset; }
 
 		/**
-		 * @brief	Gets the size of the sprite in the referenced texture.
+		 * Gets the size of the sprite in the referenced texture.
 		 *
 		 * @return	Size in UV coordinates, range [0, 1].
 		 */
 		Vector2 getScale() const { return mUVScale; }
 
 		/**
-		 * @brief	Sets the size of the sprite in the referenced texture.
+		 * Sets the size of the sprite in the referenced texture.
 		 *
 		 * @param	scale	Size in UV coordinates, range [0, 1].
 		 */
 		void setScale(const Vector2& scale) { mUVScale = scale; }
 
-		/**
-		 * @brief	Transforms wanted UV coordinates into coordinates you
-		 *			can use for sampling the internal texture.
-		 */
+		/** Transforms wanted UV coordinates into coordinates you can use for sampling the internal texture. */
 		Vector2 transformUV(const Vector2& uv) const;
 
-		/**
-		 * @brief	Returns a dummy sprite texture.
-		 */
+		/**	Returns a dummy sprite texture. */
 		static const HSpriteTexture& dummy();
 
-		/**
-		 * @brief	Returns width of the sprite texture in pixels.
-		 */
+		/**	Returns width of the sprite texture in pixels. */
 		UINT32 getWidth() const;
 
-		/**
-		 * @brief	Returns height of the sprite texture in pixels.
-		 */
+		/**	Returns height of the sprite texture in pixels. */
 		UINT32 getHeight() const;
 
-		/**
-		 * @brief	Creates a new sprite texture that references the entire area of the provided
-		 *			texture.
-		 */
+		/**	Creates a new sprite texture that references the entire area of the provided texture. */
 		static HSpriteTexture create(const HTexture& texture);
 
-		/**
-		 * @brief	Creates a new sprite texture that references a sub-area of the provided
-		 *			texture.
-		 */
+		/**	Creates a new sprite texture that references a sub-area of the provided	texture. */
 		static HSpriteTexture create(const Vector2& uvOffset, const Vector2& uvScale, const HTexture& texture);
 
-		/**
-		 * @brief	Checks if the sprite texture and its internal texture have been loaded.
-		 */
+		/**	Checks if the sprite texture and its internal texture have been loaded. */
 		static bool checkIsLoaded(const HSpriteTexture& tex);
 	private:
 		friend class SpriteTextureRTTI;
 
-		/**
-		 * @copydoc	create(const Vector2&, const Vector2&, const HTexture&)
-		 */
+		/** @copydoc create(const Vector2&, const Vector2&, const HTexture&) */
 		SpriteTexture(const Vector2& uvOffset, const Vector2& uvScale, const HTexture& texture);
 
-		/**
-		 * @copydoc	Resource::getResourceDependencies
-		 */
+		/** @copydoc Resource::getResourceDependencies */
 		void getResourceDependencies(FrameVector<HResource>& dependencies) const override;
 
-		/**
-		 * @copydoc	CoreObject::getCoreDependencies
-		 */
+		/** @copydoc CoreObject::getCoreDependencies */
 		void getCoreDependencies(Vector<CoreObject*>& dependencies) override;
 
 		HTexture mAtlasTexture;
@@ -115,13 +91,13 @@ namespace BansheeEngine
 		/* 								RTTI		                     		*/
 		/************************************************************************/
 
-		/**
-		 * @brief	Creates a new empty and uninitialized sprite texture. To be used by factory methods.
-		 */
+		/**	Creates a new empty and uninitialized sprite texture. To be used by factory methods. */
 		static SpriteTexturePtr createEmpty();
 	public:
 		friend class SpriteTextureRTTI;
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsTextSprite.h

@@ -9,25 +9,23 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Specifies how is text horizontally aligned within its bounds.
+	/** @addtogroup 2D
+	 *  @{
 	 */
+
+	/**	Specifies how is text horizontally aligned within its bounds. */
 	enum TextHorzAlign
 	{
 		THA_Left, THA_Center, THA_Right
 	};
 
-	/**
-	 * @brief	Specifies how is text vertically aligned within its bounds.
-	 */
+	/**	Specifies how is text vertically aligned within its bounds. */
 	enum TextVertAlign
 	{
 		TVA_Top, TVA_Center, TVA_Bottom
 	};
 
-	/**
-	 * @brief	Text sprite description structure used for initializing or updating a text sprite.
-	 */
+	/**	Text sprite description structure used for initializing or updating a text sprite. */
 	struct TEXT_SPRITE_DESC
 	{
 		TEXT_SPRITE_DESC()
@@ -49,9 +47,7 @@ namespace BansheeEngine
 		bool wordBreak; /**< If enabled together with word wrap it will allow words to be broken if they don't fit. */
 	};
 
-	/**
-	 * @brief	A sprite consisting of a quads representing a text string.
-	 */
+	/**	A sprite consisting of a quads representing a text string. */
 	class BS_EXPORT TextSprite : public Sprite
 	{
 	public:
@@ -59,67 +55,70 @@ namespace BansheeEngine
 		~TextSprite();
 
 		/**
-		 * @brief	Recreates internal sprite data according the specified description structure.
+		 * Recreates internal sprite data according the specified description structure.
 		 *
-		 * @param	desc	Describes the geometry and material of the sprite.
-		 * @param	groupId	Group identifier that forces different materials to be used for
-		 *					different groups (e.g. you don't want the sprites to
-		 *					share the same group if they use different world transform matrices)
+		 * @param[in]	desc	Describes the geometry and material of the sprite.
+		 * @param[in]	groupId	Group identifier that forces different materials to be used for different groups (e.g. you
+		 *						don't want the sprites to share the same group if they use different world transform
+		 *						matrices).
 		 */
 		void update(const TEXT_SPRITE_DESC& desc, UINT64 groupId);
 
 		/**
-		 * @brief	Calculates and returns offset for each individual text line. The offsets provide
-		 *			information on how much to offset the lines within provided bounds.
+		 * Calculates and returns offset for each individual text line. The offsets provide information on how much to 
+		 * offset the lines within provided bounds.
 		 *
-		 * @param	textData	Text data to generate offsets for.
-		 * @param	width		Width of the text bounds into which to constrain the text, in pixels.
-		 * @param	height		Height of the text bounds into which to constrain the text, in pixels.
-		 * @param	horzAlign	Specifies how is text horizontally aligned within its bounds.
-		 * @param	vertAlign	Specifies how is text vertically aligned within its bounds.
-		 * @param	output		Pre-allocated buffer to output the results in. Buffer must have an element
-		 *						for every line in \p textData.
+		 * @param[in]	textData	Text data to generate offsets for.
+		 * @param[in]	width		Width of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	height		Height of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	horzAlign	Specifies how is text horizontally aligned within its bounds.
+		 * @param[in]	vertAlign	Specifies how is text vertically aligned within its bounds.
+		 * @param[out]	output		Pre-allocated buffer to output the results in. Buffer must have an element
+		 *							for every line in @p textData.
 		 */
 		static void getAlignmentOffsets(const TextDataBase& textData, 
 			UINT32 width, UINT32 height, TextHorzAlign horzAlign, TextVertAlign vertAlign, Vector2I* output);
 
 		/**
-		 * @brief	Calculates text quads you may use for text rendering, based on the specified text
-		 * 			data. Only generates quads for the specified page.
-		 *
-		 * @param	page			Font page to generate the data for.
-		 * @param	textData		Text data to generate offsets for.
-		 * @param	width			Width of the text bounds into which to constrain the text, in pixels.
-		 * @param	height			Height of the text bounds into which to constrain the text, in pixels.
-		 * @param	horzAlign		Specifies how is text horizontally aligned within its bounds.
-		 * @param	vertAlign		Specifies how is text vertically aligned within its bounds.
-		 * @param	anchor			Determines how to anchor the text within the bounds.
-		 * @param	vertices		Output buffer containing quad positions. Must be allocated and of adequate size.
-		 * @param	uv				Output buffer containing quad UV coordinates. Must be allocated and of adequate size. Can be null.
-		 * @param	indices			Output buffer containing quad indices. Must be allocated and of adequate size. Can be null.
-		 * @param	bufferSizeQuads	Size of the output buffers, in number of quads.
+		 * Calculates text quads you may use for text rendering, based on the specified text data. Only generates quads for
+		 * the specified page.
 		 *
-		 * @returns	Number of generated quads.
+		 * @param[in]	page			Font page to generate the data for.
+		 * @param[in]	textData		Text data to generate offsets for.
+		 * @param[in]	width			Width of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	height			Height of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	horzAlign		Specifies how is text horizontally aligned within its bounds.
+		 * @param[in]	vertAlign		Specifies how is text vertically aligned within its bounds.
+		 * @param[in]	anchor			Determines how to anchor the text within the bounds.
+		 * @param[out]	vertices		Output buffer containing quad positions. Must be allocated and of adequate size.
+		 * @param[out]	uv				Output buffer containing quad UV coordinates. Must be allocated and of adequate 
+		 *								size. Can be null.
+		 * @param[out]	indices			Output buffer containing quad indices. Must be allocated and of adequate size. Can
+		 *								be null.
+		 * @param[in]	bufferSizeQuads	Size of the output buffers, in number of quads.
+		 * @return						Number of generated quads.
 		 */
 		static UINT32 genTextQuads(UINT32 page, const TextDataBase& textData, UINT32 width, UINT32 height, 
 			TextHorzAlign horzAlign, TextVertAlign vertAlign, SpriteAnchor anchor, Vector2* vertices, Vector2* uv, UINT32* indices, 
 			UINT32 bufferSizeQuads);
 
 		/**
-		 * @brief	Calculates text quads you may use for text rendering, based on the specified text data. Generates quads for all pages.
+		 * Calculates text quads you may use for text rendering, based on the specified text data. Generates quads for all 
+		 * pages.
 		 * 			
-		 * @param	textData		Text data to generate offsets for.
-		 * @param	width			Width of the text bounds into which to constrain the text, in pixels.
-		 * @param	height			Height of the text bounds into which to constrain the text, in pixels.
-		 * @param	horzAlign		Specifies how is text horizontally aligned within its bounds.
-		 * @param	vertAlign		Specifies how is text vertically aligned within its bounds.
-		 * @param	anchor			Determines how to anchor the text within the bounds.
-		 * @param	vertices		Output buffer containing quad positions. Must be allocated and of adequate size.
-		 * @param	uv				Output buffer containing quad UV coordinates. Must be allocated and of adequate size. Can be null.
-		 * @param	indices			Output buffer containing quad indices. Must be allocated and of adequate size. Can be null.
-		 * @param	bufferSizeQuads	Size of the output buffers, in number of quads.
-		 *
-		 * @returns	Number of generated quads.
+		 * @param[in]	textData		Text data to generate offsets for.
+		 * @param[in]	width			Width of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	height			Height of the text bounds into which to constrain the text, in pixels.
+		 * @param[in]	horzAlign		Specifies how is text horizontally aligned within its bounds.
+		 * @param[in]	vertAlign		Specifies how is text vertically aligned within its bounds.
+		 * @param[in]	anchor			Determines how to anchor the text within the bounds.
+		 * @param[out]	vertices		Output buffer containing quad positions. Must be allocated and of adequate size.
+		 * @param[out]	uv				Output buffer containing quad UV coordinates. Must be allocated and of adequate 
+		 *								size. Can be null.
+		 * @param[out]	indices			Output buffer containing quad indices. Must be allocated and of adequate size. Can
+		 *								be null.
+		 * @param[in]	bufferSizeQuads	Size of the output buffers, in number of quads.
+		 * @return						Number of generated quads.
 		 */
 		static UINT32 genTextQuads(const TextDataBase& textData, UINT32 width, UINT32 height,
 			TextHorzAlign horzAlign, TextVertAlign vertAlign, SpriteAnchor anchor, Vector2* vertices, Vector2* uv, UINT32* indices, 
@@ -129,11 +128,11 @@ namespace BansheeEngine
 		static const int STATIC_CHARS_TO_BUFFER = 25;
 		static const int STATIC_BUFFER_SIZE = STATIC_CHARS_TO_BUFFER * (4 * (2 * sizeof(Vector2)) + (6 * sizeof(UINT32)));
 
-		/**
-		 * @brief	Clears internal geometry buffers.
-		 */
+		/**	Clears internal geometry buffers. */
 		void clearMesh();
 
 		mutable StaticAlloc<STATIC_BUFFER_SIZE, STATIC_BUFFER_SIZE> mAlloc;
 	};
+
+	/** @} */
 }

BansheeEngine/Source/BsCCamera.cpp

@@ -1,99 +1,88 @@
-#include "BsCCamera.h"
-#include "BsCCameraRTTI.h"
-#include "BsMath.h"
-#include "BsMatrix3.h"
-#include "BsVector2.h"
-#include "BsAABox.h"
-#include "BsSphere.h"
-#include "BsHardwareBufferManager.h"
-#include "BsVertexBuffer.h"
-#include "BsIndexBuffer.h"
-#include "BsException.h"
-#include "BsRenderAPI.h"
-#include "BsSceneObject.h"
-#include "BsDebug.h"
-#include "BsSceneManager.h"
-
-namespace BansheeEngine 
-{
-	CCamera::CCamera(const HSceneObject& parent, RenderTargetPtr target, float left, float top, float width, float height)
-		: Component(parent), mTarget(target), mLeft(left), mTop(top), mWidth(width), mHeight(height)
-    {
-		setName("Camera");
-    }
-
-    CCamera::~CCamera()
-    {
-		mInternal->destroy();
-    }
-
-	ConvexVolume CCamera::getWorldFrustum() const
-	{
-		const Vector<Plane>& frustumPlanes = getFrustum().getPlanes();
-		Matrix4 worldMatrix = SO()->getWorldTfrm();
-
-		Vector<Plane> worldPlanes(frustumPlanes.size());
-		UINT32 i = 0;
-		for (auto& plane : frustumPlanes)
-		{
-			worldPlanes[i] = worldMatrix.multiplyAffine(plane);
-			i++;
-		}
-
-		return ConvexVolume(worldPlanes);
-	}
-
-	void CCamera::updateView() const
-	{
-		UINT32 curHash = SO()->getTransformHash();
-		if (curHash != mInternal->_getLastModifiedHash())
-		{
-			mInternal->setPosition(SO()->getWorldPosition());
-			mInternal->setRotation(SO()->getWorldRotation());
-
-			mInternal->_setLastModifiedHash(curHash);
-		}
-	}
-
-	void CCamera::setMain(bool main)
-	{
-		mInternal->setMain(main);
-
-		gSceneManager()._notifyMainCameraStateChanged(mInternal);
-	}
-
-	void CCamera::update() 
-	{
-
-	}
-
-	void CCamera::onInitialized()
-	{
-		// If mInternal already exists this means this object was deserialized,
-		// so all we need to do is initialize it.
-		if (mInternal != nullptr)
-			mInternal->initialize();
-		else
-		{
-			mInternal = Camera::create(mTarget, mLeft, mTop, mWidth, mHeight);
-			mTarget = nullptr;
-		}
-
-		gSceneManager()._registerCamera(mInternal, SO());
-	}
-
-	void CCamera::onDestroyed()
-	{
-		gSceneManager()._unregisterCamera(mInternal);
-	}
-
-	RTTITypeBase* CCamera::getRTTIStatic()
-	{
-		return CCameraRTTI::instance();
-	}
-
-	RTTITypeBase* CCamera::getRTTI() const
-	{
-		return CCamera::getRTTIStatic();
-	}
-} 
+#include "BsCCamera.h"
+#include "BsCCameraRTTI.h"
+#include "BsSceneObject.h"
+#include "BsSceneManager.h"
+
+namespace BansheeEngine 
+{
+	CCamera::CCamera(const HSceneObject& parent, RenderTargetPtr target, float left, float top, float width, float height)
+		: Component(parent), mTarget(target), mLeft(left), mTop(top), mWidth(width), mHeight(height)
+    {
+		setName("Camera");
+    }
+
+    CCamera::~CCamera()
+    {
+		mInternal->destroy();
+    }
+
+	ConvexVolume CCamera::getWorldFrustum() const
+	{
+		const Vector<Plane>& frustumPlanes = getFrustum().getPlanes();
+		Matrix4 worldMatrix = SO()->getWorldTfrm();
+
+		Vector<Plane> worldPlanes(frustumPlanes.size());
+		UINT32 i = 0;
+		for (auto& plane : frustumPlanes)
+		{
+			worldPlanes[i] = worldMatrix.multiplyAffine(plane);
+			i++;
+		}
+
+		return ConvexVolume(worldPlanes);
+	}
+
+	void CCamera::updateView() const
+	{
+		UINT32 curHash = SO()->getTransformHash();
+		if (curHash != mInternal->_getLastModifiedHash())
+		{
+			mInternal->setPosition(SO()->getWorldPosition());
+			mInternal->setRotation(SO()->getWorldRotation());
+
+			mInternal->_setLastModifiedHash(curHash);
+		}
+	}
+
+	void CCamera::setMain(bool main)
+	{
+		mInternal->setMain(main);
+
+		gSceneManager()._notifyMainCameraStateChanged(mInternal);
+	}
+
+	void CCamera::update() 
+	{
+
+	}
+
+	void CCamera::onInitialized()
+	{
+		// If mInternal already exists this means this object was deserialized,
+		// so all we need to do is initialize it.
+		if (mInternal != nullptr)
+			mInternal->initialize();
+		else
+		{
+			mInternal = Camera::create(mTarget, mLeft, mTop, mWidth, mHeight);
+			mTarget = nullptr;
+		}
+
+		gSceneManager()._registerCamera(mInternal, SO());
+	}
+
+	void CCamera::onDestroyed()
+	{
+		gSceneManager()._unregisterCamera(mInternal);
+	}
+
+	RTTITypeBase* CCamera::getRTTIStatic()
+	{
+		return CCameraRTTI::instance();
+	}
+
+	RTTITypeBase* CCamera::getRTTI() const
+	{
+		return CCamera::getRTTIStatic();
+	}
+}