More work on improving documentation for doxygen generation

BansheeEngine/Include/BsApplication.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Application-Engine
+	 *  @{
+	 */
+
 	/**	Types of available render systems. */
 	enum class RenderAPIPlugin
 	{
@@ -89,4 +94,7 @@ namespace BansheeEngine
 
 	/** Easy way to access Application. */
 	BS_EXPORT Application& gApplication();
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsBuiltinResources.h

@@ -10,6 +10,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Resources-Engine
+	 *  @{
+	 */
+
 	/**	Types of builtin meshes that are always available in the engine. */
 	enum class BuiltinMesh
 	{
@@ -301,6 +305,8 @@ namespace BansheeEngine
 		static const WString TextureNormalFile;
 	};
 
+	/** @cond INTERNAL */
+
 	/**	Provides various methods commonly used for managing builtin resources. */
 	class BS_EXPORT BuiltinResourcesHelper
 	{
@@ -333,4 +339,7 @@ namespace BansheeEngine
 		 */
 		static bool checkForModifications(const Path& folder, const Path& timeStampFile);
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCCameraRTTI.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT CCameraRTTI : public RTTIType<CCamera, Component, CCameraRTTI>
 	{
 	private:
@@ -21,20 +26,23 @@ namespace BansheeEngine
 			addReflectablePtrField("mInternal", 0, &CCameraRTTI::getInternal, &CCameraRTTI::setInternal);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "CCamera";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_CCamera;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GameObjectRTTI::createGameObject<CCamera>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCGUIWidgetRTTI.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT CGUIWidgetRTTI : public RTTIType <CGUIWidget, Component, CGUIWidgetRTTI>
 	{
 	private:
@@ -17,20 +22,23 @@ namespace BansheeEngine
 		CGUIWidgetRTTI()
 		{ }
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "CGUIWidget";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_CGUIWidget;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GameObjectRTTI::createGameObject<CGUIWidget>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCLightRTTI.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT CLightRTTI : public RTTIType <CLight, Component, CLightRTTI>
 	{
 	private:
@@ -21,20 +26,23 @@ namespace BansheeEngine
 			addReflectablePtrField("mInternal", 0, &CLightRTTI::getInternal, &CLightRTTI::setInternal);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "CLight";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_CLight;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GameObjectRTTI::createGameObject<CLight>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCRenderableRTTI.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT CRenderableRTTI : public RTTIType<CRenderable, Component, CRenderableRTTI>
 	{
 	private:
@@ -21,20 +26,23 @@ namespace BansheeEngine
 			addReflectablePtrField("mInternal", 0, &CRenderableRTTI::getInternal, &CRenderableRTTI::setInternal);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "CRenderable";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_CRenderable;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GameObjectRTTI::createGameObject<CRenderable>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCamera.h

@@ -16,18 +16,19 @@
 
 namespace BansheeEngine 
 {
-	/**
-	 * @brief	Projection type to use by the camera.
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/**	Projection type to use by the camera. */
     enum ProjectionType
     {
-		PT_ORTHOGRAPHIC, /*< Projection type where object size remains constant and parallel lines remain parallel. */
-		PT_PERSPECTIVE /*< Projection type that emulates human vision. Objects farther away appear smaller. */
+		PT_ORTHOGRAPHIC, /**< Projection type where object size remains constant and parallel lines remain parallel. */
+		PT_PERSPECTIVE /**< Projection type that emulates human vision. Objects farther away appear smaller. */
     };
 
-	/**
-	 * @brief	Clip planes that form the camera frustum (visible area).
-	 */
+	/**	Clip planes that form the camera frustum (visible area). */
     enum FrustumPlane
     {
         FRUSTUM_PLANE_NEAR = 0,
@@ -38,20 +39,24 @@ namespace BansheeEngine
         FRUSTUM_PLANE_BOTTOM = 5
     };
 
-	/**
-	 * @brief	Flags that describe a camera.
-	 */
+	/**	Flags that describe a camera. */
 	enum class CameraFlags
 	{
-		/** This flag is a signal to the renderer that his camera will only render overlays and doesn't require depth   
-		 * buffer or multi-sampled render targets. This can improve performance and memory usage. */
+		/** 
+		 * This flag is a signal to the renderer that his camera will only render overlays and doesn't require depth   
+		 * buffer or multi-sampled render targets. This can improve performance and memory usage. 
+		 */
 		Overlay = 1
 	};
 
+	/** @} */
+	/** @addtogroup Implementation
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Camera determines how is world geometry projected onto a 2D surface. You may
-	 *			position and orient it in space, set options like aspect ratio and field or view
-	 *			and it outputs view and projection matrices required for rendering.
+	 * Camera determines how is world geometry projected onto a 2D surface. You may position and orient it in space, set
+	 * options like aspect ratio and field or view and it outputs view and projection matrices required for rendering.
 	 */
 	class BS_EXPORT CameraBase
     {
@@ -59,285 +64,234 @@ namespace BansheeEngine
 		virtual ~CameraBase() { }
 
 		/**
-		 * @brief	Sets the camera horizontal field of view. This determines how wide the camera
-		 *			viewing angle is along the horizontal axis. Vertical FOV is calculated from the
-		 *			horizontal FOV and the aspect ratio.
+		 * Sets the camera horizontal field of view. This determines how wide the camera viewing angle is along the
+		 * horizontal axis. Vertical FOV is calculated from the horizontal FOV and the aspect ratio.
 		 */
         virtual void setHorzFOV(const Radian& fovy);
 
-		/**
-		 * @brief	Retrieves the camera horizontal field of view.
-		 */
+		/**	Retrieves the camera horizontal field of view. */
         virtual const Radian& getHorzFOV() const;
 
 		/**
-		 * @brief	Sets the distance from the frustum to the near clipping plane. Anything
-		 *			closer than the near clipping plane will not be rendered. Decreasing this value
-		 *			decreases depth buffer precision.
+		 * Sets the distance from the frustum to the near clipping plane. Anything closer than the near clipping plane will
+		 * not be rendered. Decreasing this value decreases depth buffer precision.
 		 */
         virtual void setNearClipDistance(float nearDist);
 
 		/**
-		 * @brief	Retrieves the distance from the frustum to the near clipping plane. Anything
-		 *			closer than the near clipping plane will not be rendered. Decreasing this value
-		 *			decreases depth buffer precision.
+		 * Retrieves the distance from the frustum to the near clipping plane. Anything closer than the near clipping plane
+		 * will not be rendered. Decreasing this value decreases depth buffer precision.
 		 */
         virtual float getNearClipDistance() const;
 
 		/**
-		 * @brief	Sets the distance from the frustum to the far clipping plane. Anything
-		 *			farther than the far clipping plane will not be rendered. Increasing this value
-		 *			decreases depth buffer precision.
+		 * Sets the distance from the frustum to the far clipping plane. Anything farther than the far clipping plane will
+		 * not be rendered. Increasing this value decreases depth buffer precision.
 		 */
         virtual void setFarClipDistance(float farDist);
 
 		/**
-		 * @brief	Retrieves the distance from the frustum to the far clipping plane. Anything
-		 *			farther than the far clipping plane will not be rendered. Increasing this value
-		 *			decreases depth buffer precision.
+		 * Retrieves the distance from the frustum to the far clipping plane. Anything farther than the far clipping plane
+		 * will not be rendered. Increasing this value decreases depth buffer precision.
 		 */
         virtual float getFarClipDistance() const;
 
-		/**
-		 * @brief	Sets the current viewport aspect ratio (width / height).
-		 */
+		/**	Sets the current viewport aspect ratio (width / height). */
         virtual void setAspectRatio(float ratio);
 
-		/**
-		 * @brief	Returns current viewport aspect ratio (width / height).
-		 */
+		/**	Returns current viewport aspect ratio (width / height). */
         virtual float getAspectRatio() const;
 
-		/**
-		 * @brief	Sets camera world space position.
-		 */
+		/**	Sets camera world space position. */
 		virtual void setPosition(const Vector3& position);
 
-		/**
-		 * @brief	Retrieves camera world space position.
-		 */
+		/**	Retrieves camera world space position. */
 		virtual Vector3 getPosition() const { return mPosition; }
 
-		/**
-		 * @brief	Sets should the camera be rendered to or not.
-		 */
+		/**	Sets should the camera be rendered to or not. */
 		void setIsActive(bool active) { mIsActive = active; _markCoreDirty(); }
 		
-		/**
-		 * @brief	Gets whether the camera be rendered to or not.
-		 */
+		/**	Gets whether the camera be rendered to or not. */
 		bool getIsActive() const { return mIsActive; }
 
 		/**
-		 * @brief	Gets the Z (forward) axis of the object, in world space.
+		 * Gets the Z (forward) axis of the object, in world space.
 		 *
 		 * @return	Forward axis of the object.
 		 */
 		Vector3 getForward() const { return getRotation().rotate(-Vector3::UNIT_Z); }
 
-		/**
-		 * @brief	Sets camera world space rotation.
-		 */
+		/**	Sets camera world space rotation. */
 		virtual void setRotation(const Quaternion& rotation);
 
-		/**
-		 * @brief	Retrieves camera world space rotation.
-		 */
+		/**	Retrieves camera world space rotation. */
 		virtual Quaternion getRotation() const { return mRotation; }
 
-		/** @brief	Manually set the extents of the frustum that will be used when calculating the
-		 *			projection matrix. This will prevents extents for being automatically calculated
-		 *			from aspect and near plane so it is up to the caller to keep these values
-		 *			accurate.
+		/** Manually set the extents of the frustum that will be used when calculating the projection matrix. This will
+		 * prevents extents for being automatically calculated from aspect and near plane so it is up to the caller to keep
+		 * these values accurate.
 		 *
-		 *	@param left		The position where the left clip plane intersect the near clip plane, in view space.
-		 *  @param right	The position where the right clip plane intersect the near clip plane, in view space.
-		 *  @param top		The position where the top clip plane intersect the near clip plane, in view space.
-		 *  @param bottom	The position where the bottom clip plane intersect the near clip plane, in view space.
+		 * @param[in] left		The position where the left clip plane intersect the near clip plane, in view space.
+		 * @param[in] right		The position where the right clip plane intersect the near clip plane, in view space.
+		 * @param[in] top		The position where the top clip plane intersect the near clip plane, in view space.
+		 * @param[in] bottom	The position where the bottom clip plane intersect the near clip plane, in view space.
 		*/
 		virtual void setFrustumExtents(float left, float right, float top, float bottom);
 
 		/** 
-		 * @brief	Resets frustum extents so they are automatically derived from other values.
-		 *			This is only relevant if you have previously set custom extents.
+		 * Resets frustum extents so they are automatically derived from other values. This is only relevant if you have
+		 * previously set custom extents.
 		 */
 		virtual void resetFrustumExtents(); 
 
-		/** 
-		 * @brief	Returns the extents of the frustum in view space at the near plane.
-		 */
+		/** Returns the extents of the frustum in view space at the near plane. */
 		virtual void getFrustumExtents(float& outleft, float& outright, float& outtop, float& outbottom) const;
 
 		/** 
-		 * @brief	Returns the standard projection matrix that determines how are 3D points
-		 *			projected to two dimensions. The layout of this matrix depends on currently
-		 *			used render system.
+		 * Returns the standard projection matrix that determines how are 3D points projected to two dimensions. The layout
+		 * of this matrix depends on currently used render system.
 		 *
-		 * @note	You should use this matrix when sending the matrix to the render system to make sure
-		 *			everything works consistently when other render systems are used.
+		 * @note	
+		 * You should use this matrix when sending the matrix to the render system to make sure everything works 
+		 * consistently when other render systems are used.
 		 */
         virtual const Matrix4& getProjectionMatrixRS() const;
 
 		/** 
-		 * @brief	Returns the inverse of the render-system specific projection matrix.
+		 * Returns the inverse of the render-system specific projection matrix.
 		 *
 		 * @see		getProjectionMatrixRS
 		 */
         virtual const Matrix4& getProjectionMatrixRSInv() const;
 
 		/** 
-		 * @brief	Returns the standard projection matrix that determines how are 3D points
-		 *			projected to two dimensions. Returned matrix is standard following right-hand
-		 *			rules and depth range of [-1, 1]. 
+		 * Returns the standard projection matrix that determines how are 3D points projected to two dimensions. Returned
+		 * matrix is standard following right-hand rules and depth range of [-1, 1]. 
 		 *
-		 * @note	Different render systems will expect different projection matrix layouts, in which
-		 *			case use getProjectionMatrixRS.
+		 * @note	
+		 * Different render systems will expect different projection matrix layouts, in which case use 
+		 * getProjectionMatrixRS().
          */
         virtual const Matrix4& getProjectionMatrix() const;
 
 		/** 
-		 * @brief	Returns the inverse of the projection matrix.
+		 * Returns the inverse of the projection matrix.
 		 *
 		 * @see		getProjectionMatrix
 		 */
         virtual const Matrix4& getProjectionMatrixInv() const;
 
-		/** 
-		 * @brief	Gets the camera view matrix. Used for positioning/orienting the camera.
-         */
+		/** Gets the camera view matrix. Used for positioning/orienting the camera. */
         virtual const Matrix4& getViewMatrix() const;
 
 		/** 
-		 * @brief	Returns the inverse of the view matrix.
+		 * Returns the inverse of the view matrix.
 		 *
 		 * @see		getViewMatrix
 		 */
 		virtual const Matrix4& getViewMatrixInv() const;
 
 		/** 
-		 * @brief	Sets whether the camera should use the custom view matrix.
-		 *			When this is enabled camera will no longer calculate its view matrix
-		 *			based on position/orientation and caller will be resonsible to keep 
-		 *			the view matrix up to date.
+		 * Sets whether the camera should use the custom view matrix. When this is enabled camera will no longer calculate
+		 * its view matrix based on position/orientation and caller will be resonsible to keep the view matrix up to date.
          */
 		virtual void setCustomViewMatrix(bool enable, const Matrix4& viewMatrix = Matrix4::IDENTITY);
 
-		/** 
-		 * @brief	Returns true if a custom view matrix is used.
-         */
+		/** Returns true if a custom view matrix is used. */
 		virtual bool isCustomViewMatrixEnabled() const { return mCustomViewMatrix; }
 		
 		/** 
-		 * @brief	Sets whether the camera should use the custom projection matrix.
-		 *			When this is enabled camera will no longer calculate its projection matrix
-		 *			based on field of view, aspect and other parameters and caller will be
-		 *			resonsible to keep the projection matrix up to date.
+		 * Sets whether the camera should use the custom projection matrix. When this is enabled camera will no longer
+		 * calculate its projection matrix based on field of view, aspect and other parameters and caller will be resonsible
+		 * to keep the projection matrix up to date.
          */
 		virtual void setCustomProjectionMatrix(bool enable, const Matrix4& projectionMatrix = Matrix4::IDENTITY);
 
-		/** 
-		 * @brief	Returns true if a custom projection matrix is used.
-         */
+		/** Returns true if a custom projection matrix is used. */
 		virtual bool isCustomProjectionMatrixEnabled() const { return mCustomProjMatrix; }
 
-		/** 
-		 * @brief	Returns a convex volume representing the visible area of the camera,
-		 *			in local space.
-         */
+		/** Returns a convex volume representing the visible area of the camera, in local space. */
         virtual const ConvexVolume& getFrustum() const;
 
-		/** 
-		 * @brief	Returns a convex volume representing the visible area of the camera,
-		 *			in world space.
-         */
+		/** Returns a convex volume representing the visible area of the camera, in world space. */
         virtual ConvexVolume getWorldFrustum() const;
 
-		/**
-		 * @brief	Returns the bounding of the frustum.
-		 */
+		/**	Returns the bounding of the frustum. */
         const AABox& getBoundingBox() const;
 
 		/**
-		 * @brief	Sets the type of projection used by the camera. Projection type 
-		 *			controls how is 3D geometry projected onto a 2D plane.
+		 * Sets the type of projection used by the camera. Projection type controls how is 3D geometry projected onto a 
+		 * 2D plane.
 		 */
         virtual void setProjectionType(ProjectionType pt);
 
 		/**
-		 * @brief	Returns the type of projection used by the camera. Projection type 
-		 *			controls how is 3D geometry projected onto a 2D plane.
+		 * Returns the type of projection used by the camera. Projection type controls how is 3D geometry projected onto a
+		 * 2D plane.
 		 */
         virtual ProjectionType getProjectionType() const;
 
 		/**
-		 * @brief	Sets the orthographic window height, for use with orthographic rendering only. 
+		 * Sets the orthographic window height, for use with orthographic rendering only. 
 		 *
-		 * @param	w	Width of the window in world units.
-		 * @param	h	Height of the window in world units.
+		 * @param[in]	w	Width of the window in world units.
+		 * @param[in]	h	Height of the window in world units.
 		 *
-		 * @note	Calling this method will recalculate the aspect ratio, use setOrthoWindowHeight or 
-		 *			setOrthoWindowWidth alone if you wish to preserve the aspect ratio but just fit one 
-		 *			or other dimension to a particular size.
+		 * @note	
+		 * Calling this method will recalculate the aspect ratio, use setOrthoWindowHeight() or setOrthoWindowWidth() alone
+		 * if you wish to preserve the aspect ratio but just fit one or other dimension to a particular size.
 		 */
 		virtual void setOrthoWindow(float w, float h);
 
 		/**
-		 * @brief	Sets the orthographic window height, for use with orthographic rendering only. 
+		 * Sets the orthographic window height, for use with orthographic rendering only. 
 		 *
-		 * @param	h	Height of the window in world units.
+		 * @param[in]	h	Height of the window in world units.
 		 *
 		 * @note	The width of the window will be calculated from the aspect ratio. 
 		 */
 		virtual void setOrthoWindowHeight(float h);
 
 		/**
-		 * @brief	Sets the orthographic window width, for use with orthographic rendering only. 
+		 * Sets the orthographic window width, for use with orthographic rendering only. 
 		 *
-		 * @param	w	Width of the window in world units.
+		 * @param[in]	w	Width of the window in world units.
 		 *
 		 * @note	The height of the window will be calculated from the aspect ratio. 
 		 */
 		virtual void setOrthoWindowWidth(float w);
 
-		/**
-		 * @brief	Gets the orthographic window width in world units, for use with orthographic rendering only. 
-		 */
+		/** Gets the orthographic window width in world units, for use with orthographic rendering only. */
 		virtual float getOrthoWindowHeight() const;
 
 		/**
-		 * @brief	Gets the orthographic window width in world units, for use with orthographic rendering only. 
+		 * Gets the orthographic window width in world units, for use with orthographic rendering only. 
 		 *
 		 * @note	This is calculated from the orthographic height and the aspect ratio.
 		 */
 		virtual float getOrthoWindowWidth() const;
 
 		/**
-		 * @brief	Gets a priority that determines in which orders the cameras are rendered.
-		 *			This only applies to cameras rendering to the same render target. 
+		 * Gets a priority that determines in which orders the cameras are rendered. This only applies to cameras rendering
+		 * to the same render target. 
 		 */
 		INT32 getPriority() const { return mPriority; }
 
 		/**
-		 * @brief	Sets a priority that determines in which orders the cameras are rendered.
-		 * 			This only applies to cameras rendering to the same render target. 
+		 * Sets a priority that determines in which orders the cameras are rendered. This only applies to cameras rendering
+		 * to the same render target. 
 		 *
-		 * @param	priority	The priority. Higher value means the camera will be rendered sooner.
+		 * @param[in]	priority	The priority. Higher value means the camera will be rendered sooner.
 		 */
 		void setPriority(INT32 priority) { mPriority = priority; _markCoreDirty(); }
 
-		/**
-		 * @brief	Retrieves layer bitfield that is used when determining which object should the camera render.
-		 */
+		/**	Retrieves layer bitfield that is used when determining which object should the camera render. */
 		UINT64 getLayers() const { return mLayers; }
 
-		/**
-		 * @brief	Sets layer bitfield that is used when determining which object should the camera render.
-		 */
+		/**	Sets layer bitfield that is used when determining which object should the camera render. */
 		void setLayers(UINT64 layers) { mLayers = layers; _markCoreDirty(); }
 
-		/**
-		 * @brief	Retrieves flags that define the camera.
-		 */
+		/**	Retrieves flags that define the camera. */
 		CameraFlags getFlags() const { return (CameraFlags)mCameraFlags; }
 
 		/**
@@ -346,116 +300,93 @@ namespace BansheeEngine
 		void setFlags(const CameraFlags& flags) { mCameraFlags = (UINT32)flags; _markCoreDirty(); }
 
 		/**
-		 * @brief	Converts a point in world space to screen coordinates (in pixels
-		 *			corresponding to the render target attached to the camera).
+		 * Converts a point in world space to screen coordinates (in pixels corresponding to the render target attached to
+		 * the camera).
 		 */
 		Vector2I worldToScreenPoint(const Vector3& worldPoint) const;
 
-		/**
-		 * @brief	Converts a point in world space to normalized clip coordinates 
-		 *			(in [0, 1] range).
-		 */
+		/**	Converts a point in world space to normalized clip coordinates (in [0, 1] range). */
 		Vector2 worldToClipPoint(const Vector3& worldPoint) const;
 
-		/**
-		 * @brief	Converts a point in world space to point relative to camera's
-		 *			coordinate system (view space).
-		 */
+		/** Converts a point in world space to point relative to camera's coordinate system (view space). */
 		Vector3 worldToViewPoint(const Vector3& worldPoint) const;
 
 		/**
-		 * @brief	Converts a point in screen space (pixels corresponding to
-		 *			render target attached to the camera) to a point in world space.
+		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to a point in
+		 * world space.
 		 *
-		 * @param	screenPoint	Point to transform.
-		 * @param	depth		Depth to place the world point at. The depth is applied
-		 *						to the vector going from camera origin to the point on
-		 *						the near plane.
+		 * @param[in]	screenPoint	Point to transform.
+		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
+		 *							origin to the point on the near plane.
 		 */
 		Vector3 screenToWorldPoint(const Vector2I& screenPoint, float depth = 0.5f) const;
 
 		/**
-		 * @brief	Converts a point in screen space (pixels corresponding to
-		 *			render target attached to the camera) to a point relative to
-		 *			camera's coordinate system (view space).
+		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to a point
+		 * relative to camera's coordinate system (view space).
 		 *
-		 * @param	screenPoint	Point to transform.
-		 * @param	depth		Depth to place the world point at. The depth is applied
-		 *						to the vector going from camera origin to the point on
-		 *						the near plane.
+		 * @param[in]	screenPoint	Point to transform.
+		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
+		 *							origin to the point on the near plane.
 		 */
 		Vector3 screenToViewPoint(const Vector2I& screenPoint, float depth = 0.5f) const;
 
 		/**
-		 * @brief	Converts a point in screen space (pixels corresponding to
-		 *			render target attached to the camera) to normalized clip 
-		 *			coordinates (in [0, 1] range).
+		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to normalized 
+		 * clip coordinates (in [0, 1] range).
 		 */
 		Vector2 screenToClipPoint(const Vector2I& screenPoint) const;
 
-		/**
-		 * @brief	Converts a point relative to camera's coordinate system (view space)
-		 *			into a point in world space.
-		 */
+		/** Converts a point relative to camera's coordinate system (view space) into a point in world space. */
 		Vector3 viewToWorldPoint(const Vector3& viewPoint) const;
 
 		/**
-		 * @brief	Converts a point relative to camera's coordinate system (view space)
-		 *			into a point in screen space (pixels corresponding to render target 
-		 *			attached to the camera.
+		 * Converts a point relative to camera's coordinate system (view space) into a point in screen space (pixels 
+		 * corresponding to render target attached to the camera).
 		 */
 		Vector2I viewToScreenPoint(const Vector3& viewPoint) const;
 
 		/**
-		 * @brief	Converts a point relative to camera's coordinate system (view space)
-		 *			into normalized clip coordinates (in [0, 1] range).
+		 * Converts a point relative to camera's coordinate system (view space) into normalized clip coordinates 
+		 * (in [0, 1] range).
 		 */
 		Vector2 viewToClipPoint(const Vector3& viewPoint) const;
 
 		/**
-		 * @brief	Converts a point in normalized clip coordinates ([0, 1] range) to
-		 *			a point in world space.
+		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point in world space.
 		 *
-		 * @param	clipPoint	Point to transform.
-		 * @param	depth		Depth to place the world point at. The depth is applied
-		 *						to the vector going from camera origin to the point on
-		 *						the near plane.
+		 * @param[in]	clipPoint	Point to transform.
+		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
+		 *							origin to the point on the near plane.
 		 */
 		Vector3 clipToWorldPoint(const Vector2& clipPoint, float depth = 0.5f) const;
 
 		/**
-		 * @brief	Converts a point in normalized clip coordinates ([0, 1] range) to
-		 *			a point relative to camera's coordinate system (view space).
+		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point relative to camera's coordinate system
+		 * (view space).
 		 *
-		 * @param	clipPoint	Point to transform.
-		 * @param	depth		Depth to place the world point at. The depth is applied
-		 *						to the vector going from camera origin to the point on
-		 *						the near plane.
+		 * @param[in]	clipPoint	Point to transform.
+		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
+		 *							origin to the point on the near plane.
 		 */
 		Vector3 clipToViewPoint(const Vector2& clipPoint, float depth = 0.5f) const;
 
 		/**
-		 * @brief	Converts a point in normalized clip coordinates ([0, 1] range) to
-		 *			a point in screen space (pixels corresponding to render target attached 
-		 *			to the camera)
+		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point in screen space (pixels corresponding
+		 * to render target attached to the camera).
 		 */
 		Vector2I clipToScreenPoint(const Vector2& clipPoint) const;
 
 		/**
-		 * @brief	Converts a point in screen space (pixels corresponding to
-		 *			render target attached to the camera) to a ray in world space
-		 *			originating at the selected point on the camera near plane.
+		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to a ray in world
+		 * space originating at the selected point on the camera near plane.
 		 */
 		Ray screenPointToRay(const Vector2I& screenPoint) const;
 
-		/**
-		 * @brief	Projects a point from view to clip space.
-		 */
+		/**	Projects a point from view to clip space. */
 		Vector3 projectPoint(const Vector3& point) const;
 
-		/**
-		 * @brief	Un-projects a point in clip space to view space.
-		 */
+		/**	Un-projects a point in clip space to view space. */
 		Vector3 unprojectPoint(const Vector3& point) const;
 
         static const float INFINITE_FAR_PLANE_ADJUST; /**< Small constant used to reduce far plane projection to avoid inaccuracies. */
@@ -463,46 +394,32 @@ namespace BansheeEngine
 	protected:
 		CameraBase();
 
-		/**
-		 * @brief	Calculate projection parameters that are used when constructing the projection matrix.
-		 */
+		/**	Calculate projection parameters that are used when constructing the projection matrix. */
 		virtual void calcProjectionParameters(float& left, float& right, float& bottom, float& top) const;
 
-		/**
-		 * @brief	Recalculate frustum if dirty.
-		 */
+		/**	Recalculate frustum if dirty. */
 		virtual void updateFrustum() const;
 
-		/**
-		 * @brief	Recalculate frustum planes if dirty.
-		 */
+		/**	Recalculate frustum planes if dirty. */
 		virtual void updateFrustumPlanes() const;
 
 		/**
-		 * @brief	Update view matrix from parent position/orientation.
+		 * Update view matrix from parent position/orientation.
 		 *
 		 * @note	Does nothing when custom view matrix is set.
 		 */
 		virtual void updateView() const;
 
-		/**
-		 * @brief	Checks if the frustum requires updating.
-		 */
+		/**	Checks if the frustum requires updating. */
 		virtual bool isFrustumOutOfDate() const;
 
-		/**
-		 * @brief	Notify camera that the frustum requires to be updated.
-		 */
+		/**	Notify camera that the frustum requires to be updated. */
 		virtual void invalidateFrustum() const;
 
-		/**
-		 * @brief	Returns a rectangle that defines the viewport position and size, in pixels.
-		 */
+		/**	Returns a rectangle that defines the viewport position and size, in pixels. */
 		virtual Rect2I getViewportRect() const = 0;
 
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		virtual void _markCoreDirty() { }
 
     protected:
@@ -541,17 +458,18 @@ namespace BansheeEngine
 		mutable AABox mBoundingBox; /**< Frustum bounding box. */
      };
 
-	/**
-	 * @copydoc	CameraBase
+	/** @} */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/** @copydoc CameraBase */
 	class BS_EXPORT CameraCore : public CoreObjectCore, public CameraBase
 	{
 	public:
 		~CameraCore();
 
-		/**
-		 * @brief	Returns the viewport used by the camera.
-		 */	
+		/**	Returns the viewport used by the camera. */	
 		SPtr<ViewportCore> getViewport() const { return mViewport; }
 
 	protected:
@@ -562,101 +480,74 @@ namespace BansheeEngine
 
 		CameraCore(const SPtr<ViewportCore>& viewport);
 
-		/**
-		 * @copydoc	CoreObjectCore::initialize
-		 */
+		/** @copydoc CoreObjectCore::initialize */
 		void initialize() override;
 
-		/**
-		 * @copydoc	CameraBase
-		 */
+		/** @copydoc CameraBase */
 		virtual Rect2I getViewportRect() const override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;
 
 		SPtr<ViewportCore> mViewport;
 	};
 
-	/**
-	 * @copydoc	CameraBase
-	 */
+	/** @copydoc CameraBase */
 	class BS_EXPORT Camera : public IReflectable, public CoreObject, public CameraBase
     {
     public:
-		/**
-		 * @brief	Returns the viewport used by the camera.
-		 */	
+		/**	Returns the viewport used by the camera. */	
 		ViewportPtr getViewport() const { return mViewport; }
 
 		/**
-		 * @brief	Determines whether this is the main application camera. Main camera controls the final render
-		 *			surface that is displayed to the user.
+		 * Determines whether this is the main application camera. Main camera controls the final render surface that is
+		 * displayed to the user.
 		 */	
 		bool isMain() const { return mMain; }
 
 		/**
-		 * @brief	Marks or unmarks this camera as the main application camera. Main camera controls the final render
-		 *			surface that is displayed to the user.
+		 * Marks or unmarks this camera as the main application camera. Main camera controls the final render surface that
+		 * is displayed to the user.
 		 */	
 		void setMain(bool main) { mMain = main; }
 
-		/**
-		 * @brief	Retrieves an implementation of a camera handler usable only from the
-		 *			core thread.
-		 */
+		/** Retrieves an implementation of a camera handler usable only from the core thread. */
 		SPtr<CameraCore> getCore() const;
 
-		/**
-	     * @brief	Returns the hash value that can be used to identify if the internal data needs an update.
-		 */
+		/**	Creates a new camera that renders to the specified portion of the provided render target. */
+		static CameraPtr create(RenderTargetPtr target = nullptr,
+			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
+
+		/** @cond INTERNAL */
+
+		/**	Returns the hash value that can be used to identify if the internal data needs an update. */
 		UINT32 _getLastModifiedHash() const { return mLastUpdateHash; }
 
-		/**
-	     * @brief	Sets the hash value that can be used to identify if the internal data needs an update.
-		 */
+		/**	Sets the hash value that can be used to identify if the internal data needs an update. */
 		void _setLastModifiedHash(UINT32 hash) { mLastUpdateHash = hash; }
 
-		/**
-		 * @brief	Creates a new camera that renders to the specified portion of the provided render target.
-		 */
-		static CameraPtr create(RenderTargetPtr target = nullptr,
-			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
+		/** @endcond */
 
 	protected:
 		Camera(RenderTargetPtr target = nullptr,
 			float left = 0.0f, float top = 0.0f, float width = 1.0f, float height = 1.0f);
 
-		/**
-		 * @copydoc	CameraBase
-		 */
+		/** @copydoc CameraBase */
 		virtual Rect2I getViewportRect() const override;
 
-		/**
-		 * @copydoc	CoreObject::createCore
-		 */
+		/** @copydoc CoreObject::createCore */
 		SPtr<CoreObjectCore> createCore() const override;
 
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		void _markCoreDirty() override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		CoreSyncData syncToCore(FrameAlloc* allocator) override;
 
-		/**
-		 * @copydoc	CoreObject::getCoreDependencies
-		 */
+		/** @copydoc CoreObject::getCoreDependencies */
 		void getCoreDependencies(Vector<CoreObject*>& dependencies) override;
 
-		/**
-		 * @brief	Creates a new camera without initializing it.
-		 */
+		/**	Creates a new camera without initializing it. */
 		static CameraPtr createEmpty();
 
 		ViewportPtr mViewport; /**< Viewport that describes 2D rendering surface. */
@@ -671,4 +562,7 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
      };
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCameraRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT CameraRTTI : public RTTIType <Camera, IReflectable, CameraRTTI>
 	{
 	private:
@@ -104,7 +109,7 @@ namespace BansheeEngine
 			addPlainField("mFlags", 22, &CameraRTTI::getFlags, &CameraRTTI::setFlags);
 		}
 
-		virtual void onDeserializationEnded(IReflectable* obj) override
+		void onDeserializationEnded(IReflectable* obj) override
 		{
 			// Note: Since this is a CoreObject I should call initialize() right after deserialization,
 			// but since this specific type is used in Components we delay initialization until Component
@@ -112,20 +117,23 @@ namespace BansheeEngine
 			// purposes (you'll need to call initialize manually).
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "Camera";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_Camera;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return Camera::createEmpty();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsCursor.h

@@ -9,16 +9,18 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Platform-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Allows you to manipulate the platform cursor in various ways.
+	 * Allows you to manipulate the platform cursor in various ways.
 	 * 			
 	 * @note	Thread safe.
 	 */
 	class BS_EXPORT Cursor : public Module<Cursor>
 	{
-		/**
-		 * @brief	Internal container for data about a single cursor icon.
-		 */
+		/**	Internal container for data about a single cursor icon. */
 		struct CustomIcon
 		{
 			CustomIcon() {}
@@ -33,97 +35,79 @@ namespace BansheeEngine
 	public:
 		Cursor();
 
-		/**
-		 * @brief	Moves the cursor to the specified screen position.
-		 */
+		/**	Moves the cursor to the specified screen position. */
 		void setScreenPosition(const Vector2I& screenPos);
 
-		/**
-		 * @brief	Retrieves the cursor position in screen coordinates.
-		 */
+		/**	Retrieves the cursor position in screen coordinates. */
 		Vector2I getScreenPosition();
 
-		/**
-		 * @brief	Hides the cursor.
-		 */
+		/**	Hides the cursor. */
 		void hide();
 
-		/**
-		 * @brief	Shows the cursor.
-		 */
+		/**	Shows the cursor. */
 		void show();
 
-		/**
-		 * @brief	Limit cursor movement to the specified window.
-		 */
+		/**	Limit cursor movement to the specified window. */
 		void clipToWindow(const RenderWindow& window);
 
-		/**
-		 * @brief	Limit cursor movement to specific area on the screen.
-		 */
+		/**	Limit cursor movement to specific area on the screen. */
 		void clipToRect(const Rect2I& screenRect);
 
-		/**
-		 * @brief	Disables cursor clipping that was set using any of the "clipTo*" methods.
-		 */
+		/**	Disables cursor clipping that was set using any of the clipTo* methods. */
 		void clipDisable();
 		
-		/**
-		 * @brief	Sets a cursor icon. Uses one of the built-in cursor types.
-		 */
+		/**	Sets a cursor icon. Uses one of the built-in cursor types. */
 		void setCursor(CursorType type);
 
 		/**
-		 * @brief	Sets a cursor icon. Uses one of the manually registered icons.
+		 * Sets a cursor icon. Uses one of the manually registered icons.
 		 * 			
-		 * @param	name		The name to identify the cursor, one set previously by calling "setCursorIcon".
+		 * @param[in]	name		The name to identify the cursor, one set previously by calling setCursorIcon().
 		 */
 		void setCursor(const String& name);
 
 		/**
-		 * @brief	Registers a new custom cursor icon you can then set by calling "setCursor".
+		 * Registers a new custom cursor icon you can then set by calling "setCursor".
 		 *
-		 * @param	name		The name to identify the cursor.
-		 * @param 	pixelData	Cursor image data.
-		 * @param	hotSpot		Offset on the cursor image to where the actual input happens (e.g. tip of the Arrow cursor).
+		 * @param[in]	name		The name to identify the cursor.
+		 * @param[in]	pixelData	Cursor image data.
+		 * @param[in]	hotSpot		Offset on the cursor image to where the actual input happens (e.g. tip of the Arrow 
+		 *							cursor).
 		 * 						
-		 * @note	Stores an internal copy of the pixel data. Clear it by calling "removeCursorIcon".
-		 * 			If a custom icon with the same name already exists it will be replaced.
+		 * @note	
+		 * Stores an internal copy of the pixel data. Clear it by calling removeCursorIcon(). If a custom icon with the 
+		 * same name already exists it will be replaced.
 		 */
 		void setCursorIcon(const String& name, const PixelData& pixelData, const Vector2I& hotSpot);
 
 		/**
-		 * @brief	Registers a new custom cursor icon you can then set by calling "setCursor".
+		 * Registers a new custom cursor icon you can then set by calling setCursor().
 		 *
-		 * @param	type		One of the built-in cursor types.
-		 * @param 	pixelData	Cursor image data.
-		 * @param	hotSpot		Offset on the cursor image to where the actual input happens (e.g. tip of the Arrow cursor).
+		 * @param[in]	type		One of the built-in cursor types.
+		 * @param[in] 	pixelData	Cursor image data.
+		 * @param[in]	hotSpot		Offset on the cursor image to where the actual input happens (e.g. tip of the Arrow 
+		 *							cursor).
 		 * 						
-		 * @note	Stores an internal copy of the pixel data. Clear it by calling "removeCursorIcon".
-		 * 			If a custom icon with the same type already exists it will be replaced.
+		 * @note	
+		 * Stores an internal copy of the pixel data. Clear it by calling removeCursorIcon(). If a custom icon with the
+		 * same type already exists it will be replaced.
 		 */
 		void setCursorIcon(CursorType type, const PixelData& pixelData, const Vector2I& hotSpot);
 
-		/**
-		 * @brief	Removes a custom cursor icon and releases any data associated with it.
-		 */
+		/**	Removes a custom cursor icon and releases any data associated with it. */
 		void clearCursorIcon(const String& name);
 
 		/**
-		 * @brief	Removes a custom cursor icon and releases any data associated with it. Restores
-		 * 			original icon associated with this cursor type.
+		 * Removes a custom cursor icon and releases any data associated with it. Restores original icon associated with
+		 * this cursor type.
 		 */
 		void clearCursorIcon(CursorType type);
 
 	private:
-		/**
-		 * @brief	Restores the default cursor icon for the specified cursor type.
-		 */
+		/**	Restores the default cursor icon for the specified cursor type. */
 		void restoreCursorIcon(CursorType type);
 
-		/**
-		 * @brief	Sends the cursor image to the OS, making it active.
-		 */
+		/**	Sends the cursor image to the OS, making it active. */
 		void updateCursorImage();
 
 		UnorderedMap<String, UINT32> mCustomIconNameToId;
@@ -131,4 +115,6 @@ namespace BansheeEngine
 		UINT32 mNextUniqueId;
 		INT32 mActiveCursorId;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsDrawHelper.h

@@ -10,16 +10,15 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Helper class for immediate drawing of common geometric shapes.
+	/** @addtogroup Utility-Engine
+	 *  @{
 	 */
+
+	/**	Helper class for immediate drawing of common geometric shapes. */
 	class BS_EXPORT DrawHelper
 	{
 	public:
-		/**
-		 * @brief	Controls in what order will elements be rendered,
-		 *			depending on some reference point
-		 */
+		/** Controls in what order will elements be rendered, depending on some reference point. */
 		enum class SortType
 		{
 			BackToFront,
@@ -27,18 +26,13 @@ namespace BansheeEngine
 			None
 		};
 
-		/**
-		 * @brief	Type of meshes that are output by DrawHelper.
-		 */
+		/**	Type of meshes that are output by DrawHelper. */
 		enum class MeshType
 		{
 			Solid, Wire, Text
 		};
 
-		/**
-		 * @brief	Container for mesh of a specific type output by
-		 *			the DrawHelper.
-		 */
+		/**	Container for mesh of a specific type output by the DrawHelper. */
 		struct ShapeMeshData
 		{
 			TransientMeshPtr mesh;
@@ -49,81 +43,51 @@ namespace BansheeEngine
 		DrawHelper();
 		~DrawHelper();
 
-		/**
-		 * @brief	Sets a color that will be used for any shapes recorded after this call.
-		 */
+		/**	Sets a color that will be used for any shapes recorded after this call. */
 		void setColor(const Color& color);
 
-		/**
-		 * @brief	Sets a transform matrix that will be used for any shapes recorded after this call.
-		 */
+		/**	Sets a transform matrix that will be used for any shapes recorded after this call. */
 		void setTransform(const Matrix4& transform);
 
-		/**
-		 * Sets the layer bitfield that can be used for filtering which objects are output into the final mesh.
-		 */
+		/** Sets the layer bitfield that can be used for filtering which objects are output into the final mesh. */
 		void setLayer(UINT64 layer);
 
-		/**
-		 * @brief	Records a solid cuboid with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid cuboid with the specified properties in the internal draw queue. */
 		void cube(const Vector3& position, const Vector3& extents);
 
-		/**
-		 * @brief	Records a solid sphere with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid sphere with the specified properties in the internal draw queue. */
 		void sphere(const Vector3& position, float radius, UINT32 quality = 1);
 
-		/**
-		 * @brief	Records a wireframe cube with the specified properties in the internal draw queue.
-		 */
+		/**	Records a wireframe cube with the specified properties in the internal draw queue. */
 		void wireCube(const Vector3& position, const Vector3& extents);
 
-		/**
-		 * @brief	Records a wireframe sphere with the specified properties in the internal draw queue.
-		 */
+		/**	Records a wireframe sphere with the specified properties in the internal draw queue. */
 		void wireSphere(const Vector3& position, float radius, UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a line with the specified properties in the internal draw queue.
-		 */
+		/**	Records a line with the specified properties in the internal draw queue. */
 		void line(const Vector3& start, const Vector3& end);
 
-		/**
-		 * @brief	Records a wireframe frustum with the specified properties in the internal draw queue.
-		 */
+		/**	Records a wireframe frustum with the specified properties in the internal draw queue. */
 		void frustum(const Vector3& position, float aspect, Degree FOV, float near, float far);
 
-		/**
-		 * @brief	Records a solid cone with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid cone with the specified properties in the internal draw queue. */
 		void cone(const Vector3& base, const Vector3& normal, float height, float radius, UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a solid disc with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid disc with the specified properties in the internal draw queue. */
 		void disc(const Vector3& position, const Vector3& normal, float radius, UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a wireframe disc with the specified properties in the internal draw queue.
-		 */
+		/**	Records a wireframe disc with the specified properties in the internal draw queue. */
 		void wireDisc(const Vector3& position, const Vector3& normal, float radius, UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a solid arc with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid arc with the specified properties in the internal draw queue. */
 		void arc(const Vector3& position, const Vector3& normal, float radius, Degree startAngle, Degree amountAngle, 
 			UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a wireframe arc with the specified properties in the internal draw queue.
-		 */
+		/**	Records a wireframe arc with the specified properties in the internal draw queue. */
 		void wireArc(const Vector3& position, const Vector3& normal, float radius, Degree startAngle, Degree amountAngle, 
 			UINT32 quality = 10);
 
-		/**
-		 * @brief	Records a solid rectangle with the specified properties in the internal draw queue.
-		 */
+		/**	Records a solid rectangle with the specified properties in the internal draw queue. */
 		void rectangle(const Rect3& area);
 
 		/**
@@ -136,9 +100,7 @@ namespace BansheeEngine
 		 */
 		void text(const Vector3& position, const WString& text, const HFont& font, UINT32 size = 10);
 
-		/**
-		 * @brief	Clears all recorded shapes.
-		 */
+		/**	Clears all recorded shapes. */
 		void clear();
 
 		/**
@@ -272,4 +234,6 @@ namespace BansheeEngine
 		VertexDataDescPtr mWireVertexDesc;
 		VertexDataDescPtr mTextVertexDesc;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsEngineShaderIncludeHandler.h

@@ -7,6 +7,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Resources-Engine
+	 *  @{
+	 */
+
 	/**
 	 * Shader include handler for the engine. It loads includes relative to the application working directory and supports
 	 * special $ENGINE$ folder for built-in includes.
@@ -20,4 +25,7 @@ namespace BansheeEngine
 		/** Converts a shader include name or path to a path of the resource containing include data. */
 		static Path toResourcePath(const String& name);
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsEnums.h

@@ -4,6 +4,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Utility-Engine
+	 *  @{
+	 */
+
 	/**	Available cursor types. */
 	enum class CursorType
 	{
@@ -30,4 +34,6 @@ namespace BansheeEngine
 	{
 		RenType_LitTextured
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsGUIElementStyleRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT GUIElementStyleRTTI : public RTTIType <GUIElementStyle, IReflectable, GUIElementStyleRTTI>
 	{
 	private:
@@ -163,20 +168,24 @@ namespace BansheeEngine
 
 			addPlainField("subStyles", 34, &GUIElementStyleRTTI::getSubStyles, &GUIElementStyleRTTI::setSubStyles);
 		}
-		virtual const String& getRTTIName()
+
+		const String& getRTTIName() override
 		{
 			static String name = "GUIElementStyle";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		UINT32 getRTTIId() override
 		{
 			return TID_GUIElementStyle;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<GUIElementStyle>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGUISkinRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT GUISkinEntry : public IReflectable
 	{
 	public:
@@ -20,7 +25,7 @@ namespace BansheeEngine
 	public:
 		friend class GUISkinEntryRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		RTTITypeBase* getRTTI() const override;
 	};
 
 	class BS_EXPORT GUISkinEntryRTTI : public RTTIType <GUISkinEntry, IReflectable, GUISkinEntryRTTI>
@@ -39,18 +44,18 @@ namespace BansheeEngine
 			addReflectableField("style", 1, &GUISkinEntryRTTI::getStyle, &GUISkinEntryRTTI::setStyle);
 		}
 
-		virtual const String& getRTTIName()
+		const String& getRTTIName() override
 		{
 			static String name = "GUISkinEntry";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		UINT32 getRTTIId() override
 		{
 			return TID_GUISkinEntry;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<GUISkinEntry>();
 		}
@@ -77,7 +82,7 @@ namespace BansheeEngine
 				&GUISkinRTTI::setStyle, &GUISkinRTTI::setStyleArraySize);
 		}
 
-		void onSerializationStarted(IReflectable* obj)
+		void onSerializationStarted(IReflectable* obj) override
 		{
 			GUISkin* skin = static_cast<GUISkin*>(obj);
 			Vector<GUISkinEntry> entries;
@@ -90,27 +95,30 @@ namespace BansheeEngine
 			skin->mRTTIData = entries;
 		}
 
-		void onSerializationEnded(IReflectable* obj)
+		void onSerializationEnded(IReflectable* obj) override
 		{
 			GUISkin* skin = static_cast<GUISkin*>(obj);
 
 			skin->mRTTIData = nullptr;
 		}
 
-		virtual const String& getRTTIName()
+		const String& getRTTIName() override
 		{
 			static String name = "GUISkin";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		UINT32 getRTTIId() override
 		{
 			return TID_GUISkin;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GUISkin::_createPtr();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGameSettings.h

@@ -7,9 +7,14 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Utility-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Contains settings used for controlling game start-up, as well as persisting various other properties
-	 * 			through game sessions.
+	 * Contains settings used for controlling game start-up, as well as persisting various other properties through game
+	 * sessions.
 	 */
 	class BS_EXPORT GameSettings : public IReflectable
 	{
@@ -29,4 +34,7 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsGameSettingsRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT GameSettingsRTTI : public RTTIType <GameSettings, IReflectable, GameSettingsRTTI>
 	{
 	private:
@@ -40,20 +45,23 @@ namespace BansheeEngine
 			addPlainField("titleBarText", 5, &GameSettingsRTTI::getTitlebarText, &GameSettingsRTTI::setTitlebarText);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "GameSettings";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_GameSettings;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<GameSettings>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsHEString.h

@@ -4,42 +4,41 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Utility-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Helper class used for constructing HString%s that references the engine string table.
-	 *			Engine string table is just a separate string table so it doesn't conflict with
-	 *			the game string table.
+	 * Helper class used for constructing HString%s that references the engine string table. Engine string table is just
+	 * a separate string table so it doesn't conflict with the game string table.
 	 */
 	class BS_EXPORT HEString
 	{
 	public:
 		/**
-		 * @brief	Creates a new localized string with the specified identifier in the engine string table. 
-		 *			If the identifier doesn't previously exist in the string table, identifier value will also 
-		 *			be used for initializing the default language version of the string.
+		 * Creates a new localized string with the specified identifier in the engine string table. If the identifier
+		 * doesn't previously exist in the string table, identifier value will also be used for initializing the default
+		 * language version of the string.
 		 *
-		 * @param	identifier		String you can use for later referencing the localized string.
+		 * @param[in]	identifier		String you can use for later referencing the localized string.
 		 */
 		HEString(const WString& identifier);
 
 		/**
-		 * @brief	Creates a new localized string with the specified identifier in the engine string table and sets the 
-		 *			default language version of the string. If a string with that identifier already exists default language 
-		 *			string will be updated.
+		 * Creates a new localized string with the specified identifier in the engine string table and sets the default
+		 * language version of the string. If a string with that identifier already exists default language string will be
+		 * updated.
 		 *
-		 * @param	identifier		String you can use for later referencing the localized string.
-		 * @param	default			Default string to assign to the specified identifier. Language to which it
-		 *							will be assigned depends on the StringTable::DEFAULT_LANGUAGE value.
+		 * @param[in]	identifier		String you can use for later referencing the localized string.
+		 * @param[in]	default			Default string to assign to the specified identifier. Language to which it
+		 *								will be assigned depends on the StringTable::DEFAULT_LANGUAGE value.
 		 */
 		HEString(const WString& identifier, const WString& default);
 
-		/**
-		 * @brief	Creates a new empty localized string in the engine string table.
-		 */
+		/**	Creates a new empty localized string in the engine string table. */
 		HEString();
 
-		/**
-		 * @brief	Implicitly casts the editor string type to a generic string type.
-		 */
+		/**	Implicitly casts the editor string type to a generic string type. */
 		operator HString() const;
 
 	private:
@@ -47,4 +46,6 @@ namespace BansheeEngine
 
 		HString mInternal;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsInputConfiguration.h

@@ -7,21 +7,25 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Input-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Describes a virtual button. Virtual buttons allow you to
-	 *			map custom actions without needing to know about what 
-	 *			physical buttons trigger those actions.
+	 * Describes a virtual button. Virtual buttons allow you to map custom actions without needing to know about what 
+	 * physical buttons trigger those actions.
 	 */
 	struct BS_EXPORT VIRTUAL_BUTTON_DESC
 	{
 		VIRTUAL_BUTTON_DESC();
 
 		/**
-		 * @brief	Constructs a virtual button descriptor.
+		 * Constructs a virtual button descriptor.
 		 *
-		 * @param	buttonCode	Physical button the virtual button is triggered by.
-		 * @param	modifiers	Modifiers required to be pressed with the physical button to trigger the virtual button.
-		 * @param	repeatable	If true, the virtual button events will be sent continually while the physical button is being held.
+		 * @param[in]	buttonCode	Physical button the virtual button is triggered by.
+		 * @param[in]	modifiers	Modifiers required to be pressed with the physical button to trigger the virtual button.
+		 * @param[in]	repeatable	If true, the virtual button events will be sent continually while the physical button 
+		 *							is being held.
 		 */
 		VIRTUAL_BUTTON_DESC(ButtonCode buttonCode, ButtonModifier modifiers = ButtonModifier::None, bool repeatable = false);
 
@@ -31,21 +35,21 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Describes a virtual axis. Virtual axes allow you to map
-	 *			custom axes without needing to know the actual physical device
-	 *			handling those axes.
+	 * Describes a virtual axis. Virtual axes allow you to map custom axes without needing to know the actual physical
+	 * device handling those axes.
 	 */
 	struct BS_EXPORT VIRTUAL_AXIS_DESC
 	{
 		VIRTUAL_AXIS_DESC();
 
 		/**
-		 * @brief	Constructs a new virtual axis descriptor.
+		 * Constructs a new virtual axis descriptor.
 		 *
-		 * @param	type		Type of physical axis to map to. See InputAxis type for common types, but you are not limited to those values.
-		 * @param	deadZone	Value below which to ignore axis value and consider it 0.
-		 * @param	sensitivity	Higher sensitivity means the axis will more easily reach its maximum values.
-		 * @param	invert		Should axis values be inverted.
+		 * @param[in]	type		Type of physical axis to map to. See InputAxis type for common types, but you are not 
+		 *							limited to those values.
+		 * @param[in]	deadZone	Value below which to ignore axis value and consider it 0.
+		 * @param[in]	sensitivity	Higher sensitivity means the axis will more easily reach its maximum values.
+		 * @param[in]	invert		Should axis values be inverted.
 		 */
 		VIRTUAL_AXIS_DESC(UINT32 type, float deadZone = 0.0001f, float sensitivity = 1.0f, bool invert = false);
 
@@ -56,13 +60,14 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Identifier for a virtual button. 
-	 * 			
-	 * @note	Primary purpose of this class is to avoid expensive string compare (i.e. button names),
-	 * 			and instead use a unique button identifier for compare. Generally you want to create 
-	 * 			one of these using the button name, and then store it for later use. 
-	 * 			
-	 *			This class is not thread safe and should only be used on the sim thread.
+	 * Identifier for a virtual button. 
+	 * 				
+	 * Primary purpose of this class is to avoid expensive string compare (i.e. button names), and instead use a unique
+	 * button identifier for compare. Generally you want to create one of these using the button name, and then store it
+	 * for later use. 
+	 *
+	 * @note			
+	 * This class is not thread safe and should only be used on the sim thread.
 	 *
 	 * @see		VIRTUAL_BUTTON_DESC
 	 */
@@ -84,13 +89,14 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Identifier for a virtual axis. 
-	 * 			
-	 * @note	Primary purpose of this class is to avoid expensive string compare (i.e. axis names),
-	 * 			and instead use a unique axis identifier for compare. Generally you want to create 
-	 * 			one of these using the axis name, and then store it for later use. 
+	 * Identifier for a virtual axis. 
 	 * 			
-	 *			This class is not thread safe and should only be used on the sim thread.
+	 * Primary purpose of this class is to avoid expensive string compare (i.e. axis names), and instead use a unique axis
+	 * identifier for compare. Generally you want to create one of these using the axis name, and then store it for later 
+	 * use. 
+	 * 
+	 * @note
+	 * This class is not thread safe and should only be used on the sim thread.
 	 *
 	 * @see		VIRTUAL_AXIS_DESC
 	 */
@@ -112,17 +118,13 @@ namespace BansheeEngine
 		static UINT32 NextAxisId;
 	};
 
-	/**
-	 * @brief	Contains virtual <-> physical key mappings.
-	 */
+	/**	Contains virtual <-> physical key mappings. */
 	class BS_EXPORT InputConfiguration
 	{
 		static const int MAX_NUM_DEVICES_PER_TYPE = 8;
 		static const int MAX_NUM_DEVICES = (UINT32)InputDevice::Count * MAX_NUM_DEVICES_PER_TYPE;
 
-		/**
-		 * @brief	Internal virtual button data container.
-		 */
+		/**	Internal virtual button data container. */
 		struct VirtualButtonData
 		{
 			String name;
@@ -130,9 +132,7 @@ namespace BansheeEngine
 			VIRTUAL_BUTTON_DESC desc;
 		};
 
-		/**
-		 * @brief	Internal virtual axis data container.
-		 */
+		/**	Internal virtual axis data container. */
 		struct VirtualAxisData
 		{
 			String name;
@@ -140,9 +140,7 @@ namespace BansheeEngine
 			VIRTUAL_AXIS_DESC desc;
 		};
 
-		/**
-		 * @brief	Internal container for holding axis data for all devices.
-		 */
+		/**	Internal container for holding axis data for all devices. */
 		struct DeviceAxisData
 		{
 			VirtualAxisData axes[(UINT32)InputAxis::Count];
@@ -152,59 +150,60 @@ namespace BansheeEngine
 		InputConfiguration();
 
 		/**
-		 * @brief	Registers a new virtual button.
+		 * Registers a new virtual button.
 		 *
-		 * @param	name		Unique name used to access the virtual button.
-		 * @param	buttonCode	Physical button the virtual button is triggered by.
-		 * @param	modifiers	Modifiers required to be pressed with the physical button to trigger the virtual button.
-		 * @param	repeatable	If true, the virtual button events will be sent continually while the physical button is being held.
+		 * @param[in]	name		Unique name used to access the virtual button.
+		 * @param[in]	buttonCode	Physical button the virtual button is triggered by.
+		 * @param[in]	modifiers	Modifiers required to be pressed with the physical button to trigger the virtual button.
+		 * @param[in]	repeatable	If true, the virtual button events will be sent continually while the physical button 
+		 *							is being held.
 		 */
 		void registerButton(const String& name, ButtonCode buttonCode, ButtonModifier modifiers = ButtonModifier::None, bool repeatable = false);
 
-		/**
-		 * @brief	Unregisters a virtual button with the specified name. Events will no longer be generated for that button.
-		 */
+		/**	Unregisters a virtual button with the specified name. Events will no longer be generated for that button. */
 		void unregisterButton(const String& name);
 
 		/**
-		 * @brief	Registers a new virtual axis.
+		 * Registers a new virtual axis.
 		 *
-		 * @param	name	Unique name used to access the axis.
-		 * @param	desc	Descriptor structure containing virtual axis creation parameters.
+		 * @param[in]	name	Unique name used to access the axis.
+		 * @param[in]	desc	Descriptor structure containing virtual axis creation parameters.
 		 */
 		void registerAxis(const String& name, const VIRTUAL_AXIS_DESC& desc);
 
 		/**
-		 * @brief	Unregisters a virtual axis with the specified name. You will no longer
-		 *			be able to retrieve valid values for that axis.
+		 * Unregisters a virtual axis with the specified name. You will no longer be able to retrieve valid values for that
+		 * axis.
 		 */
 		void unregisterAxis(const String& name);
 
 		/**
-		 * @brief	Sets repeat interval for held virtual buttons. Buttons will be continously triggered in
-		 * 			interval increments as long as they button is being held.
+		 * Sets repeat interval for held virtual buttons. Buttons will be continously triggered in interval increments as
+		 * long as they button is being held.
 		 */
 		void setRepeatInterval(UINT64 milliseconds) { mRepeatInterval = milliseconds; }
 
-		/**
-		 * @brief	Gets the currently set repeat interval for held virtual buttons.
-		 */
+		/**	Gets the currently set repeat interval for held virtual buttons. */
 		UINT64 getRepeatInterval() const { return mRepeatInterval; }
 
-		/**
-		 * @brief	Returns data about virtual buttons that are triggered 
-		 *			by the specified physical button code and modifier flags.
+		/** @cond INTERNAL */
+
+		/** 
+		 * Returns data about virtual buttons that are triggered by the specified physical button code and modifier flags. 
 		 */
 		bool _getButtons(ButtonCode code, UINT32 modifiers, Vector<VirtualButton>& btns, Vector<VIRTUAL_BUTTON_DESC>& btnDescs) const;
 
-		/**
-		 * @brief	Retrieves virtual axis descriptor for the provided axis.
-		 */
+		/**	Retrieves virtual axis descriptor for the provided axis. */
 		bool _getAxis(const VirtualAxis& axis, VIRTUAL_AXIS_DESC& axisDesc) const;
+
+		/** @endcond */
+
 	private:
 		Vector<VirtualButtonData> mButtons[BC_Count];
 		Vector<VirtualAxisData> mAxes;
 
 		UINT64 mRepeatInterval;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsLight.h

@@ -12,6 +12,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
+	 */
+
 	/** Light type that determines how is light information parsed by the renderer and other systems. */
 	enum class LightType
 	{
@@ -27,6 +32,12 @@ namespace BansheeEngine
 		Everything = 0x02
 	};
 
+	/** @} */
+
+	/** @addtogroup Implementation
+	 *  @{
+	 */
+
 	/**
 	 * Illuminates a portion of the scene covered by a light. Base class for both sim and core thread Light implementations.
 	 */
@@ -168,6 +179,11 @@ namespace BansheeEngine
 		bool mPhysCorrectAtten; /**< Determines is physically based attentuation active. */
 	};
 
+	/** @} */
+	/** @addtogroup Renderer-Engine
+	 *  @{
+	 */
+
 	/**
 	 * Core thread usable version of a light.
 	 *
@@ -275,4 +291,7 @@ namespace BansheeEngine
 	protected:
 		Light(); // Serialization only
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsLightRTTI.h

@@ -1,82 +1,90 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#pragma once
-
-#include "BsPrerequisites.h"
-#include "BsRTTIType.h"
-#include "BsLight.h"
-
-namespace BansheeEngine
-{
-	class BS_EXPORT LightRTTI : public RTTIType <Light, IReflectable, LightRTTI>
-	{
-	private:
-		Vector3& getPosition(Light* obj) { return obj->mPosition; }
-		void setPosition(Light* obj, Vector3& position) { obj->mPosition = position; }
-
-		Quaternion& getRotation(Light* obj) { return obj->mRotation; }
-		void setRotation(Light* obj, Quaternion& rotation) { obj->mRotation = rotation; }
-
-		LightType& getType(Light* obj) { return obj->mType; }
-		void setType(Light* obj, LightType& type) { obj->mType = type; }
-
-		bool& getCastsShadow(Light* obj) { return obj->mCastsShadows; }
-		void setCastsShadow(Light* obj, bool& castsShadow) { obj->mCastsShadows = castsShadow; }
-
-		Color& getColor(Light* obj) { return obj->mColor; }
-		void setColor(Light* obj, Color& color) { obj->mColor = color; }
-
-		float& getRange(Light* obj) { return obj->mRange; }
-		void setRange(Light* obj, float& range) { obj->mRange = range; }
-
-		float& getIntensity(Light* obj) { return obj->mIntensity; }
-		void setIntensity(Light* obj, float& intensity) { obj->mIntensity = intensity; }
-
-		Degree& getSpotAngle(Light* obj) { return obj->mSpotAngle; }
-		void setSpotAngle(Light* obj, Degree& spotAngle) { obj->mSpotAngle = spotAngle; }
-
-		Degree& getSpotFalloffAngle(Light* obj) { return obj->mSpotFalloffAngle; }
-		void setSpotFalloffAngle(Light* obj, Degree& spotAngle) { obj->mSpotFalloffAngle = spotAngle; }
-
-		bool& getPhysCorrectAtten(Light* obj) { return obj->mPhysCorrectAtten; }
-		void setPhysCorrectAtten(Light* obj, bool& value) { obj->mPhysCorrectAtten = value; }
-	public:
-		LightRTTI()
-		{
-			addPlainField("mPosition", 0, &LightRTTI::getPosition, &LightRTTI::setPosition);
-			addPlainField("mRotation", 1, &LightRTTI::getRotation, &LightRTTI::setRotation);
-			addPlainField("mType", 2, &LightRTTI::getType, &LightRTTI::setType);
-			addPlainField("mCastsShadow", 3, &LightRTTI::getCastsShadow, &LightRTTI::setCastsShadow);
-			addPlainField("mColor", 4, &LightRTTI::getColor, &LightRTTI::setColor);
-			addPlainField("mRange", 5, &LightRTTI::getRange, &LightRTTI::setRange);
-			addPlainField("mIntensity", 6, &LightRTTI::getIntensity, &LightRTTI::setIntensity);
-			addPlainField("mSpotAngle", 7, &LightRTTI::getSpotAngle, &LightRTTI::setSpotAngle);
-			addPlainField("mSpotFalloffAngle", 8, &LightRTTI::getSpotFalloffAngle, &LightRTTI::setSpotFalloffAngle);
-			addPlainField("mPhysCorrectAtten", 9, &LightRTTI::getPhysCorrectAtten, &LightRTTI::setPhysCorrectAtten);
-		}
-
-		virtual void onDeserializationEnded(IReflectable* obj) override
-		{
-			// Note: Since this is a CoreObject I should call initialize() right after deserialization,
-			// but since this specific type is used in Components we delay initialization until Component
-			// itself does it. Keep this is mind in case this ever needs to be deserialized for non-Component 
-			// purposes (you'll need to call initialize manually).
-		}
-
-		virtual const String& getRTTIName() override
-		{
-			static String name = "Light";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId() override
-		{
-			return TID_Light;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
-		{
-			return Light::createEmpty();
-		}
-	};
+#pragma once
+
+#include "BsPrerequisites.h"
+#include "BsRTTIType.h"
+#include "BsLight.h"
+
+namespace BansheeEngine
+{
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
+	class BS_EXPORT LightRTTI : public RTTIType <Light, IReflectable, LightRTTI>
+	{
+	private:
+		Vector3& getPosition(Light* obj) { return obj->mPosition; }
+		void setPosition(Light* obj, Vector3& position) { obj->mPosition = position; }
+
+		Quaternion& getRotation(Light* obj) { return obj->mRotation; }
+		void setRotation(Light* obj, Quaternion& rotation) { obj->mRotation = rotation; }
+
+		LightType& getType(Light* obj) { return obj->mType; }
+		void setType(Light* obj, LightType& type) { obj->mType = type; }
+
+		bool& getCastsShadow(Light* obj) { return obj->mCastsShadows; }
+		void setCastsShadow(Light* obj, bool& castsShadow) { obj->mCastsShadows = castsShadow; }
+
+		Color& getColor(Light* obj) { return obj->mColor; }
+		void setColor(Light* obj, Color& color) { obj->mColor = color; }
+
+		float& getRange(Light* obj) { return obj->mRange; }
+		void setRange(Light* obj, float& range) { obj->mRange = range; }
+
+		float& getIntensity(Light* obj) { return obj->mIntensity; }
+		void setIntensity(Light* obj, float& intensity) { obj->mIntensity = intensity; }
+
+		Degree& getSpotAngle(Light* obj) { return obj->mSpotAngle; }
+		void setSpotAngle(Light* obj, Degree& spotAngle) { obj->mSpotAngle = spotAngle; }
+
+		Degree& getSpotFalloffAngle(Light* obj) { return obj->mSpotFalloffAngle; }
+		void setSpotFalloffAngle(Light* obj, Degree& spotAngle) { obj->mSpotFalloffAngle = spotAngle; }
+
+		bool& getPhysCorrectAtten(Light* obj) { return obj->mPhysCorrectAtten; }
+		void setPhysCorrectAtten(Light* obj, bool& value) { obj->mPhysCorrectAtten = value; }
+	public:
+		LightRTTI()
+		{
+			addPlainField("mPosition", 0, &LightRTTI::getPosition, &LightRTTI::setPosition);
+			addPlainField("mRotation", 1, &LightRTTI::getRotation, &LightRTTI::setRotation);
+			addPlainField("mType", 2, &LightRTTI::getType, &LightRTTI::setType);
+			addPlainField("mCastsShadow", 3, &LightRTTI::getCastsShadow, &LightRTTI::setCastsShadow);
+			addPlainField("mColor", 4, &LightRTTI::getColor, &LightRTTI::setColor);
+			addPlainField("mRange", 5, &LightRTTI::getRange, &LightRTTI::setRange);
+			addPlainField("mIntensity", 6, &LightRTTI::getIntensity, &LightRTTI::setIntensity);
+			addPlainField("mSpotAngle", 7, &LightRTTI::getSpotAngle, &LightRTTI::setSpotAngle);
+			addPlainField("mSpotFalloffAngle", 8, &LightRTTI::getSpotFalloffAngle, &LightRTTI::setSpotFalloffAngle);
+			addPlainField("mPhysCorrectAtten", 9, &LightRTTI::getPhysCorrectAtten, &LightRTTI::setPhysCorrectAtten);
+		}
+
+		void onDeserializationEnded(IReflectable* obj) override
+		{
+			// Note: Since this is a CoreObject I should call initialize() right after deserialization,
+			// but since this specific type is used in Components we delay initialization until Component
+			// itself does it. Keep this is mind in case this ever needs to be deserialized for non-Component 
+			// purposes (you'll need to call initialize manually).
+		}
+
+		const String& getRTTIName() override
+		{
+			static String name = "Light";
+			return name;
+		}
+
+		UINT32 getRTTIId() override
+		{
+			return TID_Light;
+		}
+
+		std::shared_ptr<IReflectable> newRTTIObject() override
+		{
+			return Light::createEmpty();
+		}
+	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsPaths.h

@@ -4,6 +4,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Utility-Engine
+	 *  @{
+	 */
+
 	static const char* ENGINE_ASSEMBLY = "MBansheeEngine";
 	static const char* SCRIPT_GAME_ASSEMBLY = "MScriptGame";
 	static const char* GAME_RESOURCES_FOLDER_NAME = "Resources\\";
@@ -47,4 +52,7 @@ namespace BansheeEngine
 		static const Path RUNTIME_DATA_PATH;
 		static const Path ENGINE_DATA_PATH;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsPlainText.h

@@ -7,31 +7,27 @@
 
 namespace BansheeEngine
 {
-	/**
-	* @brief	A resource containing plain text data.
-	*/
+	/** @addtogroup Resources-Engine
+	 *  @{
+	 */
+
+	/**	A resource containing plain text data. */
 	class BS_EXPORT PlainText : public Resource
 	{
 	public:
-		/**
-		 * @brief	Returns the text contained in the resource.
-		 */
+		/**	Returns the text contained in the resource. */
 		const WString& getString() const { return mString; }
 
-		/**
-		 * @brief	Modifies the text contained in the resource.
-		 */
+		/**	Modifies the text contained in the resource. */
 		void setString(const WString& data) { mString = data; }
 
-		/**
-		 * @brief	Creates a new text file resource with the specified string.
-		 */
+		/**	Creates a new text file resource with the specified string. */
 		static HPlainText create(const WString& data);
 
 		/**
-		 * @brief	Creates an include file resource with the specified include string.
+		 * Creates an include file resource with the specified include string.
 		 *
-		 * @note	Internal method. Use "create" for normal use.
+		 * @note	Internal method. Use create() for normal use.
 		 */
 		static PlainTextPtr _createPtr(const WString& data);
 	private:
@@ -47,4 +43,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsPlainTextImporter.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Imports plain text files (.txt, .xml, .json).
+	/** @cond INTERNAL */
+	/** @addtogroup Resources-Engine
+	 *  @{
 	 */
+
+	/**	Imports plain text files (.txt, .xml, .json). */
 	class BS_EXPORT PlainTextImporter : public SpecificImporter
 	{
 	public:
@@ -27,4 +30,7 @@ namespace BansheeEngine
 
 		static const WString DEFAULT_EXTENSION;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsPlainTextRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT PlainTextRTTI : public RTTIType <PlainText, Resource, PlainTextRTTI>
 	{
 	private:
@@ -19,20 +24,23 @@ namespace BansheeEngine
 			addPlainField("mString", 0, &PlainTextRTTI::getString, &PlainTextRTTI::setString);
 		}
 
-		virtual const String& getRTTIName()
+		const String& getRTTIName() override
 		{
 			static String name = "PlainText";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		UINT32 getRTTIId() override
 		{
 			return TID_PlainText;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return PlainText::_createPtr(L""); // Initial string doesn't matter, it'll get overwritten
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsPrerequisites.h

@@ -36,7 +36,7 @@
  *  Types containing RTTI for specific classes.
  */
 
-/** @defgroup Resources Resources
+/** @defgroup Resources-Engine Resources
   *	Contains engine resource types and manager for builtin resources.
   */
 
@@ -48,6 +48,10 @@
  *  Platform specific functionality.
  */
 
+/** @defgroup Script Script
+ *  Functionality for dealing with scripting languages and libraries.
+ */
+
 /** @defgroup Application-Engine Application
  *  Entry point into the application.
  */

BansheeEngine/Include/BsProfilerOverlayRTTI.h

@@ -9,6 +9,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT ProfilerOverlayRTTI : public RTTIType <ProfilerOverlay, Component, ProfilerOverlayRTTI>
 	{
 	private:
@@ -17,20 +22,23 @@ namespace BansheeEngine
 		ProfilerOverlayRTTI()
 		{ }
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "ProfilerOverlay";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_ProfilerOverlay;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return GameObjectRTTI::createGameObject<ProfilerOverlay>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRectOffset.h

@@ -6,10 +6,11 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Rectangle represented in the form of offsets
-	 *			from some parent rectangle.
+	/** @addtogroup Utility-Engine
+	 *  @{
 	 */
+
+	/** Rectangle represented in the form of offsets from some parent rectangle. */
 	struct RectOffset
 	{
 		RectOffset()
@@ -23,5 +24,9 @@ namespace BansheeEngine
 		INT32 left, right, top, bottom;
 	};
 
+	/** @} */
+
+	/** @cond SPECIALIZATIONS */
 	BS_ALLOW_MEMCPY_SERIALIZATION(RectOffset);
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderQueue.h

@@ -8,9 +8,13 @@
 
 namespace BansheeEngine 
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Controls if and how a render queue groups renderable objects
-	 * 			by material in order to reduce number of state changes.
+	 * Controls if and how a render queue groups renderable objects by material in order to reduce number of state changes.
 	 */
 	enum class StateReduction
 	{
@@ -19,9 +23,7 @@ namespace BansheeEngine
 		Distance /**< Elements will be grouped by distance first, material second. */
 	};
 
-	/**
-	 * @brief	Contains data needed for performing a single rendering pass.
-	 */
+	/** Contains data needed for performing a single rendering pass. */
 	struct BS_EXPORT RenderQueueElement
 	{
 		RenderQueueElement()
@@ -34,15 +36,13 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Render objects determines rendering order of objects contained within it. Rendering order 
-	 *			is determined by object material, and can influence rendering of transparent or opaque objects,
-	 * 			or be used to improve performance by grouping similar objects together.
+	 * Render objects determines rendering order of objects contained within it. Rendering order is determined by object
+	 * material, and can influence rendering of transparent or opaque objects, or be used to improve performance by grouping
+	 * similar objects together.
 	 */
 	class BS_EXPORT RenderQueue
 	{
-		/**
-		 * @brief	Data used for renderable element sorting. Represents a single pass for a single mesh.
-		 */
+		/**	Data used for renderable element sorting. Represents a single pass for a single mesh. */
 		struct SortableElement
 		{
 			UINT32 seqIdx;
@@ -57,49 +57,36 @@ namespace BansheeEngine
 		virtual ~RenderQueue() { }
 
 		/**
-		 * @brief	Adds a new entry to the render queue.
+		 * Adds a new entry to the render queue.
 		 *
-		 * @param	element			Renderable element to add to the queue.
-		 * @param	distFromCamera	Distance of this object from the camera. Used for distance sorting.
+		 * @param[in]	element			Renderable element to add to the queue.
+		 * @param[in]	distFromCamera	Distance of this object from the camera. Used for distance sorting.
 		 */
 		void add(RenderableElement* element, float distFromCamera);
 
-		/**
-		 * @brief	Clears all render operations from the queue.
-		 */
+		/**	Clears all render operations from the queue. */
 		void clear();
 		
-		/**
-		 * @brief	Sorts all the render operations using user-defined rules.
-		 */
+		/**	Sorts all the render operations using user-defined rules. */
 		virtual void sort();
 
-		/**
-		 * @brief	Returns a list of sorted render elements. Caller must ensure
-		 * 			"sort" is called before this method.
-		 */
+		/** Returns a list of sorted render elements. Caller must ensure sort() is called before this method. */
 		const Vector<RenderQueueElement>& getSortedElements() const;
 
 		/**
-		 * @brief	Controls if and how a render queue groups renderable objects by 
-		 * 			material in order to reduce number of state changes.
+		 * Controls if and how a render queue groups renderable objects by material in order to reduce number of state 
+		 * changes.
 		 */
 		void setStateReduction(StateReduction mode) { mStateReductionMode = mode; }
 
 	protected:
-		/**
-		 * @brief	Callback used for sorting elements with no material grouping.
-		 */
+		/**	Callback used for sorting elements with no material grouping. */
 		static bool elementSorterNoGroup(UINT32 aIdx, UINT32 bIdx, const Vector<SortableElement>& lookup);
 
-		/**
-		 * @brief	Callback used for sorting elements with preferred material grouping.
-		 */
+		/**	Callback used for sorting elements with preferred material grouping. */
 		static bool elementSorterPreferGroup(UINT32 aIdx, UINT32 bIdx, const Vector<SortableElement>& lookup);
 
-		/**
-		 * @brief	Callback used for sorting elements with material grouping after sorting.
-		 */
+		/**	Callback used for sorting elements with material grouping after sorting. */
 		static bool elementSorterPreferSort(UINT32 aIdx, UINT32 bIdx, const Vector<SortableElement>& lookup);
 
 		Vector<SortableElement> mSortableElements;
@@ -109,4 +96,7 @@ namespace BansheeEngine
 		Vector<RenderQueueElement> mSortedRenderElements;
 		StateReduction mStateReductionMode;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderable.h

@@ -11,9 +11,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Signals which portion of a Renderable is dirty.
+	/** @cond INTERNAL */
+	/** @addtogroup Implementation
+	 *  @{
 	 */
+
+	/**	Signals which portion of a Renderable is dirty. */
 	enum class RenderableDirtyFlag
 	{
 		Transform = 0x01,
@@ -21,9 +24,8 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Renderable represents any visible object in the scene. It has a mesh,
-	 *			bounds and a set of materials. Renderer will render any Renderable objects
-	 *			visible by a camera.
+	 * Renderable represents any visible object in the scene. It has a mesh, bounds and a set of materials. Renderer will
+	 * render any Renderable objects visible by a camera.
 	 */
 	template<bool Core>
 	class BS_EXPORT TRenderable
@@ -44,112 +46,85 @@ namespace BansheeEngine
 		virtual ~TRenderable();
 
 		/**
-		 * @brief	Sets the mesh to render. All sub-meshes of the mesh will be rendered,
-		 *			and you may set individual materials for each sub-mesh.
+		 * Sets the mesh to render. All sub-meshes of the mesh will be rendered, and you may set individual materials for
+		 * each sub-mesh.
 		 */
 		void setMesh(const MeshType& mesh);
 
 		/**
-		 * @brief	Sets a material that will be used for rendering a sub-mesh with
-		 *			the specified index. If a sub-mesh doesn't have a specific material set
-		 *			then the primary material will be used.
+		 * Sets a material that will be used for rendering a sub-mesh with the specified index. If a sub-mesh doesn't have
+		 * a specific material set then the primary material will be used.
 		 */
 		void setMaterial(UINT32 idx, const MaterialType& material);
 
 		/**
-		 * @brief	Sets the primary material to use for rendering. Any sub-mesh that
-		 *			doesn't have an explicit material set will use this material.
+		 * Sets the primary material to use for rendering. Any sub-mesh that doesn't have an explicit material set will use
+		 * this material.
 		 *
 		 * @note	This is equivalent to calling setMaterial(0, material).
 		 */
 		void setMaterial(const MaterialType& material);
 
 		/**
-		 * @brief	Returns all materials used for rendering this renderable. Each of the materials is used for rendering
-		 * 			a single sub-mesh.
+		 * Returns all materials used for rendering this renderable. Each of the materials is used for rendering a single
+		 * sub-mesh.
 		 */
 		const Vector<MaterialType>& getMaterials() { return mMaterials; }
 
 		/**
-		 * @brief	Sets all materials used for rendering this renderable. Each of the materials is used for rendering
-		 * 			a single sub-mesh. If number of materials is larger than number of sub-meshes, they will be ignored.
-		 * 			If lower, the remaining materials will be removed.
+		 * Sets all materials used for rendering this renderable. Each of the materials is used for rendering a single
+		 * sub-mesh. If number of materials is larger than number of sub-meshes, they will be ignored. If lower, the
+		 * remaining materials will be removed.
 		 */
 		void setMaterials(const Vector<MaterialType>& materials);
 
 		/**
-		 * @brief	Sets the layer bitfield that controls whether a renderable is considered 
-		 *			visible in a specific camera. Renderable layer must match camera layer
-		 *			in order for the camera to render the component.
+		 * Sets the layer bitfield that controls whether a renderable is considered visible in a specific camera. Renderable
+		 * layer must match camera layer in order for the camera to render the component.
 		 */
 		void setLayer(UINT64 layer);
 
-		/**
-		 * @brief	Sets the transform matrix that is applied to the object
-		 *			when its being rendered.
-		 */
+		/** Sets the transform matrix that is applied to the object when its being rendered. */
 		void setTransform(const Matrix4& transform, const Matrix4& transformNoScale);
 
-		/**
-		 * @brief	Sets whether the object should be rendered or not.
-		 */
+		/**	Sets whether the object should be rendered or not. */
 		void setIsActive(bool active);
 
 		/**
-		 * @brief	Gets the layer bitfield that controls whether a renderable is considered 
-		 *			visible in a specific camera. Renderable layer must match camera layer
-		 *			in order for the camera to render the component.
+		 * Gets the layer bitfield that controls whether a renderable is considered visible in a specific camera. 
+		 * Renderable layer must match camera layer in order for the camera to render the component.
 		 */
 		UINT64 getLayer() const { return mLayer; }
 
-		/**
-		 * @brief	Returns the mesh used for rendering.
-		 */
+		/**	Returns the mesh used for rendering. */
 		MeshType getMesh() const { return mMesh; }
 
-		/**
-		 * @brief	Returns the material used for rendering a sub-mesh with
-		 *			the specified index.
-		 */
+		/**	Returns the material used for rendering a sub-mesh with the specified index. */
 		MaterialType getMaterial(UINT32 idx) const { return mMaterials[idx]; }
 
-		/**
-		 * @brief	Returns the transform matrix that is applied to the object
-		 *			when its being rendered.
-		 */
+		/**	Returns the transform matrix that is applied to the object when its being rendered. */
 		Matrix4 getTransform() const { return mTransform; }
 
 		/**
-		 * @brief	Returns the transform matrix that is applied to the object
-		 *			when its being rendered. This transform matrix does not
-		 *			include scale values.
+		 * Returns the transform matrix that is applied to the object when its being rendered. This transform matrix does 
+		 * not include scale values.
 		 */
 		Matrix4 getTransformNoScale() const { return mTransformNoScale; }
 
-		/**
-		 * @brief	Gets whether the object should be rendered or not.
-		 */
+		/**	Gets whether the object should be rendered or not. */
 		bool getIsActive() const { return mIsActive; }
 
-		/**
-		 * @brief	Retrieves the world position of the renderable.
-		 */
+		/**	Retrieves the world position of the renderable. */
 		Vector3 getPosition() const { return mPosition; }
 
 	protected:
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		virtual void _markCoreDirty(RenderableDirtyFlag flag = RenderableDirtyFlag::Everything) { }
 
-		/**
-		 * @copydoc	CoreObject::markDependenciesDirty
-		 */
+		/** @copydoc CoreObject::markDependenciesDirty */
 		virtual void _markDependenciesDirty() { }
 
-		/**
-		 * @copydoc	IResourceListener::markResourcesDirty
-		 */
+		/** @copydoc IResourceListener::markResourcesDirty */
 		virtual void _markResourcesDirty() { }
 
 		MeshType mMesh;
@@ -162,32 +137,28 @@ namespace BansheeEngine
 		bool mIsActive;
 	};
 
-	/**
-	 * @copydoc	TRenderable
+	/** @} */
+
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/** @copydoc TRenderable */
 	class BS_EXPORT RenderableCore : public CoreObjectCore, public TRenderable<true>
 	{
 	public:
 		~RenderableCore();
 
-		/**
-		 * @brief	Gets world bounds of the mesh rendered by this object.
-		 */
+		/**	Gets world bounds of the mesh rendered by this object. */
 		Bounds getBounds() const;
 
-		/**
-		 * @brief	Returns the type that controls how is this object rendered.
-		 */
+		/**	Returns the type that controls how is this object rendered. */
 		RenderableType getRenderableType() const { return RenType_LitTextured; }
 
-		/**
-		 * @brief	Sets an ID that can be used for uniquely identifying this handler by the renderer.
-		 */
+		/**	Sets an ID that can be used for uniquely identifying this handler by the renderer. */
 		void setRendererId(UINT32 id) { mRendererId = id; }
 
-		/**
-		 * @brief	Retrieves an ID that can be used for uniquely identifying this handler by the renderer.
-		 */
+		/**	Retrieves an ID that can be used for uniquely identifying this handler by the renderer. */
 		UINT32 getRendererId() const { return mRendererId; }
 
 	protected:
@@ -195,102 +166,65 @@ namespace BansheeEngine
 
 		RenderableCore();
 
-		/**
-		 * @copydoc	CoreObject::initialize
-		 */
+		/** @copydoc CoreObject::initialize */
 		void initialize() override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		void syncToCore(const CoreSyncData& data) override;
 
 		UINT32 mRendererId;
 	};
 
-	/**
-	 * @copydoc	TRenderable
-	 */
+	/** @copydoc TRenderable */
 	class BS_EXPORT Renderable : public IReflectable, public CoreObject, public TRenderable<false>, public IResourceListener
 	{
 	public:
-		/**
-		 * @brief	Gets world bounds of the mesh rendered by this object.
-		 */
+		/**	Gets world bounds of the mesh rendered by this object. */
 		Bounds getBounds() const;
 
-		/**
-		 * @brief	Retrieves an implementation of a renderable handler usable only from the
-		 *			core thread.
-		 */
+		/**	Retrieves an implementation of a renderable handler usable only from the core thread. */
 		SPtr<RenderableCore> getCore() const;
 
-		/**
-	     * @brief	Returns the hash value that can be used to identify if the internal data needs an update.
-		 */
+		/**	Returns the hash value that can be used to identify if the internal data needs an update. */
 		UINT32 _getLastModifiedHash() const { return mLastUpdateHash; }
 
-		/**
-	     * @brief	Sets the hash value that can be used to identify if the internal data needs an update.
-		 */
+		/**	Sets the hash value that can be used to identify if the internal data needs an update. */
 		void _setLastModifiedHash(UINT32 hash) { mLastUpdateHash = hash; }
 
-		/**
-		 * @brief	Creates a new renderable handler instance.
-		 */
+		/**	Creates a new renderable handler instance. */
 		static RenderablePtr create();
 
 	protected:
 		Renderable();
 
-		/**
-		 * @copydoc	CoreObject::createCore
-		 */
+		/** @copydoc CoreObject::createCore */
 		SPtr<CoreObjectCore> createCore() const override;
 
-		/**
-		 * @copydoc	CoreObject::markCoreDirty
-		 */
+		/** @copydoc CoreObject::markCoreDirty */
 		void _markCoreDirty(RenderableDirtyFlag flag = RenderableDirtyFlag::Everything) override;
 
-		/**
-		* @copydoc	IResourceListener::markResourcesDirty
-		*/
+		/** @copydoc IResourceListener::markResourcesDirty */
 		void _markResourcesDirty() override;
 
-		/**
-		 * @copydoc	CoreObject::markDependenciesDirty
-		 */
+		/** @copydoc CoreObject::markDependenciesDirty */
 		void _markDependenciesDirty() override;
 
-		/**
-		 * @copydoc	CoreObject::syncToCore
-		 */
+		/** @copydoc CoreObject::syncToCore */
 		CoreSyncData syncToCore(FrameAlloc* allocator) override;
 
-		/**
-		 * @copydoc	CoreObject::getCoreDependencies
-		 */
+		/** @copydoc CoreObject::getCoreDependencies */
 		void getCoreDependencies(Vector<CoreObject*>& dependencies) override;
 
-		/**
-		 * @copydoc	IResourceListener::getListenerResources
-		 */
+		/** @copydoc IResourceListener::getListenerResources */
 		void getListenerResources(Vector<HResource>& resources) override;
 
-		/**
-		 * @copydoc IResourceListener::notifyResourceLoaded
-		 */
+		/** @copydoc IResourceListener::notifyResourceLoaded */
 		void notifyResourceLoaded(const HResource& resource) override;
 
-		/**
-		 * @copydoc IResourceListener::notifyResourceChanged
-		 */
+		/** @copydoc IResourceListener::notifyResourceChanged */
 		void notifyResourceChanged(const HResource& resource) override;
 
-		/**
-		 * @brief	Creates a new renderable handler instance without initializing it.
-		 */
+		/**	Creates a new renderable handler instance without initializing it. */
 		static RenderablePtr createEmpty();
 
 		UINT32 mLastUpdateHash;
@@ -303,4 +237,7 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderableElement.h

@@ -9,17 +9,16 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains all information needed for rendering a single
-	 *			sub-mesh. Closely tied with Renderer.
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/** Contains all information needed for rendering a single sub-mesh. Closely tied with Renderer. */
 	class BS_EXPORT RenderableElement
 	{
 	public:
-		/**
-		 * @brief	Contains a hardware GPU parameter buffer and index of the parameters and the slot
-		 *			it binds to in a material.
-		 */
+		/**	Contains a hardware GPU parameter buffer and index of the parameters and the slot it binds to in a material. */
 		struct BS_EXPORT BufferBindInfo
 		{
 			BufferBindInfo(UINT32 passIdx, UINT32 paramsIdx, UINT32 slotIdx, const SPtr<GpuParamBlockBufferCore>& buffer)
@@ -32,26 +31,21 @@ namespace BansheeEngine
 			SPtr<GpuParamBlockBufferCore> buffer;
 		};
 
-		/**
-		 * @brief	Reference to the mesh to render.
-		 */
+		/**	Reference to the mesh to render. */
 		SPtr<MeshCore> mesh;
 
-		/**
-		 * @brief	Portion of the mesh to render.
-		 */
+		/**	Portion of the mesh to render. */
 		SubMesh subMesh;
 
-		/**
-		 * @brief	Material to render the mesh with.
-		 */
+		/**	Material to render the mesh with. */
 		SPtr<MaterialCore> material;
 
-		/**
-		 * @brief	Custom data that may optionally be set by the RenderableHanbdler.
-		 */
+		/**	Custom data that may optionally be set by the RenderableHanbdler. */
 		Any rendererData;
 
 		Vector<BufferBindInfo> rendererBuffers;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderableHandler.h

@@ -6,12 +6,17 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
+	 */
+
 	/**
-	 * Abstract class that provides an interface for initializing renderable elements of a 
-	 * certain type, along with their GPU parameter buffers.
+	 * Abstract class that provides an interface for initializing renderable elements of a certain type, along with their
+	 * GPU parameter buffers.
 	 *
-	 * Essentially this class holds all the information that is needed for rendering
-	 * an element of a certain renderable type.
+	 * Essentially this class holds all the information that is needed for rendering an element of a certain renderable 
+	 * type.
 	 */
 	class BS_EXPORT RenderableHandler
 	{
@@ -19,21 +24,18 @@ namespace BansheeEngine
 		virtual ~RenderableHandler() {}
 
 		/**
-		 * @brief	Initializes the specified renderable element, making it ready
-		 *			to be used. Caller must ensure the renderable element actually
-		 *			supports this handler.
+		 * Initializes the specified renderable element, making it ready to be used. Caller must ensure the renderable
+		 * element actually supports this handler.
 		 */
 		virtual void initializeRenderElem(RenderableElement& element) = 0;
 
-		/**
-		 * @brief	Binds per object GPU parameter buffers to the provided element.
-		 */
+		/**	Binds per object GPU parameter buffers to the provided element. */
 		virtual void bindPerObjectBuffers(const RenderableElement& element) = 0;
 
-		/**
-		 * @brief	Binds global GPU parameter buffers used for this Renderable 
-		 *			type to the provided element.
-		 */
+		/** Binds global GPU parameter buffers used for this Renderable type to the provided element. */
 		virtual void bindGlobalBuffers(const RenderableElement& element);
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderableRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT RenderableRTTI : public RTTIType<Renderable, IReflectable, RenderableRTTI>
 	{
 	private:
@@ -31,7 +36,7 @@ namespace BansheeEngine
 				&RenderableRTTI::getNumMaterials, &RenderableRTTI::setMaterial, &RenderableRTTI::setNumMaterials);
 		}
 
-		virtual void onDeserializationEnded(IReflectable* obj) override
+		void onDeserializationEnded(IReflectable* obj) override
 		{
 			// Note: Since this is a CoreObject I should call initialize() right after deserialization,
 			// but since this specific type is used in Components we delay initialization until Component
@@ -39,20 +44,23 @@ namespace BansheeEngine
 			// purposes (you'll need to call initialize manually).
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "Renderable";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_Renderable;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return Renderable::createEmpty();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRenderer.h

@@ -7,65 +7,63 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @copydoc	CoreRenderer
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/** @copydoc CoreRenderer */
 	class BS_EXPORT Renderer : public CoreRenderer
 	{
 	public:
 		virtual ~Renderer() { }
 
 		/**
-		 * @brief	Called whenever a new renderable is created.
+		 * Called whenever a new renderable is created.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyRenderableAdded(RenderableCore* renderable) { }
 
 		/**
-		 * @brief	Called whenever a renderable is updated.
+		 * Called whenever a renderable is updated.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyRenderableUpdated(RenderableCore* renderable) { }
 
 		/**
-		 * @brief	Called whenever a renderable is destroyed.
+		 * Called whenever a renderable is destroyed.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyRenderableRemoved(RenderableCore* renderable) { }
 
 		/**
-		 * @brief	Called whenever a new light is created.
+		 * Called whenever a new light is created.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyLightAdded(LightCore* light) { }
 
 		/**
-		 * @brief	Called whenever a light is updated.
+		 * Called whenever a light is updated.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyLightUpdated(LightCore* light) { }
 
 		/**
-		 * @brief	Called whenever a light is destroyed.
+		 * Called whenever a light is destroyed.
 		 *
 		 * @note	Core thread.
-		 *			Internal method.
 		 */
 		virtual void _notifyLightRemoved(LightCore* light) { }
 	};
 
-	/**
-	 * @brief	Retrieves the currently active renderer.
-	 */
+	/**	Provides easy access to Renderer. */
 	SPtr<Renderer> BS_EXPORT gRenderer();
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRendererMaterial.h

@@ -15,17 +15,18 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains data common to all render material instances of a specific type.
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/**	Contains data common to all render material instances of a specific type. */
 	struct RendererMaterialMetaData
 	{
 		SPtr<ShaderCore> shader;
 	};
 
-	/**
-	 * @brief	Base class for all RendererMaterial instances, containing common data and methods.
-	 */
+	/**	Base class for all RendererMaterial instances, containing common data and methods. */
 	class BS_EXPORT RendererMaterialBase
 	{
 	public:
@@ -42,9 +43,7 @@ namespace BansheeEngine
 		SPtr<MaterialCore> mMaterial;
 	};
 
-	/**
-	 * @brief	Helper class to initialize all renderer materials as soon as the library is loaded.
-	 */
+	/**	Helper class to initialize all renderer materials as soon as the library is loaded. */
 	template <class T>
 	struct InitRendererMaterialStart
 	{
@@ -54,16 +53,11 @@ namespace BansheeEngine
 			T::_initMetaData();
 		}
 
-		/**
-		 * @brief	Forces the compiler to not optimize out construction of this type.
-		 */
+		/**	Forces the compiler to not optimize out construction of this type. */
 		void instantiate() { }
 	};
 
-	/**
-	 * @brief	Wrapper class around Material that allows a simple way to load 
-	 * 			and set up materials used by the renderer.
-	 */
+	/** Wrapper class around Material that allows a simple way to load and set up materials used by the renderer. */
 	template<class T>
 	class RendererMaterial : public RendererMaterialBase
 	{
@@ -88,4 +82,7 @@ namespace BansheeEngine
 
 	template<class T>
 	RendererMaterialMetaData RendererMaterial<T>::mMetaData;
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsRendererMaterialManager.h

@@ -8,17 +8,18 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
+	 */
+
 	class RendererMaterialBase;
 	struct RendererMaterialMetaData;
 
-	/**
-	 * @brief	Initializes and handles all renderer materials.
-	 */
+	/**	Initializes and handles all renderer materials. */
 	class BS_EXPORT RendererMaterialManager : public Module<RendererMaterialManager>
 	{
-		/**
-		 * @brief	Information used for initializing a renderer material managed by this module.
-		 */	
+		/**	Information used for initializing a renderer material managed by this module. */	
 		struct RendererMaterialData
 		{
 			RendererMaterialMetaData* metaData;
@@ -29,33 +30,26 @@ namespace BansheeEngine
 		RendererMaterialManager();
 		~RendererMaterialManager();
 
-		/**
-		 * @brief	Registers a new material that should be initialized on module start-up.
-		 */
+		/**	Registers a new material that should be initialized on module start-up. */
 		static void _registerMaterial(RendererMaterialMetaData* metaData, const Path& shaderPath);
 
 	private:
 		template<class T>
 		friend class RendererMaterial;
 
-		/**
-		 * @brief	Initializes all materials on the core thread.
-		 */
+		/**	Initializes all materials on the core thread. */
 		static void initOnCore(const Vector<SPtr<ShaderCore>>& shaders);
 
-		/**
-		 * @brief	Destroys all materials on the core thread.
-		 */
+		/**	Destroys all materials on the core thread. */
 		static void destroyOnCore();
 
-		/**
-		 * @brief	Returns a list in which are all materials managed by this module.
-		 */
+		/**	Returns a list in which are all materials managed by this module. */
 		static Vector<RendererMaterialData>& getMaterials();
 
-		/**
-		 * @brief	Returns a mutex used for inter-thread access to the materials list.
-		 */
+		/**	Returns a mutex used for inter-thread access to the materials list. */
 		static Mutex& getMutex();
 	};
+
+	/** @} */
+	/** @endgroup */
 }

BansheeEngine/Include/BsSceneManager.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains information about a camera managed by the scene manager.
+	/** @cond INTERNAL */
+	/** @addtogroup Renderer-Engine
+	 *  @{
 	 */
+
+	/**	Contains information about a camera managed by the scene manager. */
 	struct SceneCameraData
 	{
 		SceneCameraData() { }
@@ -22,9 +25,7 @@ namespace BansheeEngine
 		HSceneObject sceneObject;
 	};
 
-	/**
-	 * @brief	Contains information about a renderable managed by the scene manager.
-	 */
+	/**	Contains information about a renderable managed by the scene manager. */
 	struct SceneRenderableData
 	{
 		SceneRenderableData() { }
@@ -37,9 +38,7 @@ namespace BansheeEngine
 		HSceneObject sceneObject;
 	};
 
-	/**
-	 * @brief	Contains information about a light managed by the scene manager.
-	 */
+	/**	Contains information about a light managed by the scene manager. */
 	struct SceneLightData
 	{
 		SceneLightData() { }
@@ -52,10 +51,7 @@ namespace BansheeEngine
 		HSceneObject sceneObject;
 	};
 
-	/**
-	 * @brief	Manages active SceneObjects and provides ways for querying
-	 *			and updating them or their components.
-	 */
+	/** Manages active SceneObjects and provides ways for querying and updating them or their components. */
 	class BS_EXPORT SceneManager : public CoreSceneManager
 	{
 	public:
@@ -76,106 +72,56 @@ namespace BansheeEngine
 		SceneManager() { }
 		virtual ~SceneManager() {}
 
-		/**
-		 * @brief	Returns all cameras in the scene.
-		 *
-		 * @note	Internal method.
-		 */
+		/** Returns all cameras in the scene. */
 		const Map<Camera*, SceneCameraData>& getAllCameras() const { return mCameras; }
 
-		/**
-		 * @brief	Returns all renderables in the scene.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Returns all renderables in the scene. */
 		const Map<Renderable*, SceneRenderableData>& getAllRenderables() const { return mRenderables; }
 
 		/**
-		 * @brief	Returns the camera in the scene marked as main. Main camera controls the final render
-		 *			surface that is displayed to the user. If there are multiple main cameras, the first one found
-		 *			returned.
-		 *
-		 * @note	Internal method.
+		 * Returns the camera in the scene marked as main. Main camera controls the final render surface that is displayed
+		 * to the user. If there are multiple main cameras, the first one found returned.
 		 */
 		SceneCameraData getMainCamera() const;
 
 		/**
-		 * @brief	Sets the render target that the main camera in the scene (if any) will render its view to. This
-		 * 			generally means the main game window when running standalone, or the Game viewport when running
-		 * 			in editor.
-		 *
-		 * @note	Internal method.
+		 * Sets the render target that the main camera in the scene (if any) will render its view to. This generally means
+		 * the main game window when running standalone, or the Game viewport when running in editor.
 		 */
 		void setMainRenderTarget(const RenderTargetPtr& rt);
 
-		/**
-		 * @brief	Notifies the scene manager that a new renderable was created.
-		 * 
-		 * @note	Internal method.
-		 */
+		/** Notifies the scene manager that a new renderable was created. */
 		void _registerRenderable(const SPtr<Renderable>& renderable, const HSceneObject& so);
 
-		/**
-		 * @brief	Notifies the scene manager that a renderable was removed.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a renderable was removed. */
 		void _unregisterRenderable(const SPtr<Renderable>& renderable);
 
-		/**
-		 * @brief	Notifies the scene manager that a new camera was created.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a new camera was created. */
 		void _registerCamera(const SPtr<Camera>& camera, const HSceneObject& so);
 
-		/**
-		 * @brief	Notifies the scene manager that a camera was removed.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a camera was removed. */
 		void _unregisterCamera(const SPtr<Camera>& camera);
 
-		/**
-		 * @brief	Notifies the scene manager that a camera either became the main camera, or has stopped being main camera.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a camera either became the main camera, or has stopped being main camera. */
 		void _notifyMainCameraStateChanged(const SPtr<Camera>& camera);
 
-		/**
-		 * @brief	Notifies the scene manager that a new light was created.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a new light was created. */
 		void _registerLight(const SPtr<Light>& light, const HSceneObject& so);
 
-		/**
-		 * @brief	Notifies the scene manager that a light was removed.
-		 *
-		 * @note	Internal method.
-		 */
+		/**	Notifies the scene manager that a light was removed. */
 		void _unregisterLight(const SPtr<Light>& light);
 
-		/**
-		 * @copydoc	CoreSceneManager::_updateCoreObjectTransforms
-		 */
+		/** @copydoc CoreSceneManager::_updateCoreObjectTransforms */
 		virtual void _updateCoreObjectTransforms() override;
 
-		/**
-		 * @copydoc	CoreSceneManager::instance
-		 */
+		/** @copydoc CoreSceneManager::instance */
 		static SceneManager& instance();
 
-		/**
-		 * @copydoc	CoreSceneManager::instancePtr
-		 */
+		/** @copydoc CoreSceneManager::instancePtr */
 		static SceneManager* instancePtr();
 
 	private:
-		/**
-		 * @brief	Callback that is triggered when the main render target size is changed.
-		 */
+		/**	Callback that is triggered when the main render target size is changed. */
 		void onMainRenderTargetResized();
 
 		Map<Camera*, SceneCameraData> mCameras;
@@ -189,8 +135,9 @@ namespace BansheeEngine
 		volatile static InitOnStart DoInitOnStart;
 	};
 
-	/**
-	 * @copydoc	SceneManager
-	 */
+	/** Provides easier access to SceneManager. */
 	BS_EXPORT SceneManager& gSceneManager();
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsScriptCode.h

@@ -7,39 +7,31 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Resource containing script source code.
+	/** @addtogroup Resources-Engine
+	 *  @{
 	 */
+
+	/**	Resource containing script source code. */
 	class BS_EXPORT ScriptCode : public Resource
 	{
 	public:
-		/**
-		 * @brief	Gets the source code contained in the resource.
-		 */
+		/**	Gets the source code contained in the resource. */
 		const WString& getString() const { return mString; }
 
-		/**
-		 * @brief	Sets the source code contained in the resource.
-		 */
+		/**	Sets the source code contained in the resource. */
 		void setString(const WString& data) { mString = data; }
 
-		/**
-		 * @brief	Gets a value that determines should the script code be compiled with editor assemblies.
-		 */
+		/**	Gets a value that determines should the script code be compiled with editor assemblies. */
 		bool getIsEditorScript() const { return mEditorScript; }
 
-		/**
-		 * @brief	Sets a value that determines should the script code be compiled with editor assemblies.
-		 */
+		/**	Sets a value that determines should the script code be compiled with editor assemblies. */
 		void setIsEditorScript(bool editorScript) { mEditorScript = editorScript; }
 
-		/**
-		 * @brief	Creates a new script code resource with the specified source code.
-		 */
+		/**	Creates a new script code resource with the specified source code. */
 		static HScriptCode create(const WString& data, bool editorScript = false);
 
 		/**
-		 * @brief	Creates a new scriptcode resource with the specified source string.
+		 * Creates a new scriptcode resource with the specified source string.
 		 *
 		 * @note	Internal method. Use "create" for normal use.
 		 */
@@ -58,4 +50,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		virtual RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsScriptCodeImportOptions.h

@@ -8,23 +8,20 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Contains import options you may use to control how is a file containing
-	 *			script source code importer.
+	/** @addtogroup Resources-Engine
+	 *  @{
 	 */
+
+	/** Contains import options you may use to control how is a file containing script source code importer. */
 	class BS_EXPORT ScriptCodeImportOptions : public ImportOptions
 	{
 	public:
 		ScriptCodeImportOptions();
 
-		/**
-		* @brief	Sets whether the script is editor-only or a normal game script.
-		*/
+		/**	Sets whether the script is editor-only or a normal game script. */
 		void setEditorScript(bool editorScript) { mEditorScript = editorScript; }
 
-		/**
-		 * @brief	Checks whether the script is editor-only or a normal game script.
-		 */
+		/**	Checks whether the script is editor-only or a normal game script. */
 		bool isEditorScript() const { return mEditorScript; }
 
 		/************************************************************************/
@@ -33,9 +30,11 @@ namespace BansheeEngine
 	public:
 		friend class ScriptCodeImportOptionsRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;
+		RTTITypeBase* getRTTI() const override;
 
 	private:
 		bool mEditorScript;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsScriptCodeImportOptionsRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT ScriptCodeImportOptionsRTTI : public RTTIType <ScriptCodeImportOptions, ImportOptions, ScriptCodeImportOptionsRTTI>
 	{
 	private:
@@ -19,20 +24,23 @@ namespace BansheeEngine
 			addPlainField("mEditorScript", 0, &ScriptCodeImportOptionsRTTI::getEditorScript, &ScriptCodeImportOptionsRTTI::setEditorScript);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "ScriptCodeImportOptions";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_ScriptCodeImportOptions;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ScriptCodeImportOptions>();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsScriptCodeImporter.h

@@ -7,9 +7,12 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Imports C# script source code files (.cs).
+	/** @cond INTERNAL */
+	/** @addtogroup Resources-Engine
+	 *  @{
 	 */
+
+	/**	Imports C# script source code files (.cs). */
 	class BS_EXPORT ScriptCodeImporter : public SpecificImporter
 	{
 	public:
@@ -30,4 +33,7 @@ namespace BansheeEngine
 
 		static const WString DEFAULT_EXTENSION;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsScriptCodeRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT ScriptCodeRTTI : public RTTIType <ScriptCode, Resource, ScriptCodeRTTI>
 	{
 	private:
@@ -23,20 +28,23 @@ namespace BansheeEngine
 			addPlainField("mEditorScript", 1, &ScriptCodeRTTI::getEditorScript, &ScriptCodeRTTI::setEditorScript);
 		}
 
-		virtual const String& getRTTIName()
+		const String& getRTTIName() override
 		{
 			static String name = "ScriptCode";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		UINT32 getRTTIId() override
 		{
 			return TID_ScriptCode;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return ScriptCode::_createPtr(L""); // Initial string doesn't matter, it'll get overwritten
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsScriptManager.h

@@ -7,65 +7,53 @@
 
 namespace BansheeEngine 
 {
-	/**
-	 * @brief	Abstraction that handles a specific set of script libraries.
+	/** @cond INTERNAL */
+	/** @addtogroup Script
+	 *  @{
 	 */
+
+	/**	Abstraction that handles a specific set of script libraries. */
 	class BS_EXPORT ScriptLibrary
 	{
 	public:
 		virtual ~ScriptLibrary() { }
 
-		/**
-		 * @brief	Called when the script system is being activated.
-		 */
+		/**	Called when the script system is being activated. */
 		virtual void initialize() = 0;
 
-		/**
-		 * @brief	Called when the script libraries should be reloaded.
-		 *			(e.g. when they are recompiled).
-		 */
+		/** Called when the script libraries should be reloaded (e.g. when they are recompiled). */
 		virtual void reload() = 0;
 
-		/**
-		 * @brief	Called when the script system is being destroyed.
-		 */
+		/**	Called when the script system is being destroyed. */
 		virtual void destroy() = 0;
 	};
 
-	/**
-	 * @brief	Handles initialization of a scripting system.
-	 */
+	/**	Handles initialization of a scripting system. */
 	class BS_EXPORT ScriptManager : public Module<ScriptManager>
 	{
 	public:
 		ScriptManager() { }
 		~ScriptManager() { }
 
-		/**
-		 * @brief	Initializes the currently active script library loading the scripts
-		 *			contained within.
-		 */
+		/** Initializes the currently active script library loading the scripts contained within. */
 		void initialize();
 
 		/**
-		 * @brief	Reloads any scripts in the currently active library. Should be called after
-		 *			some change to the scripts was made (e.g. project was changed, or scripts were
-		 *			recompiled).
+		 * Reloads any scripts in the currently active library. Should be called after some change to the scripts was made
+		 * (e.g. project was changed, or scripts were recompiled).
 		 */
 		void reload();
 
-		/**
-		 * @brief	Sets the active script library that controls what kind and which
-		 *			scripts are loaded.
-		 */
+		/** Sets the active script library that controls what kind and which scripts are loaded. */
 		void _setScriptLibrary(const SPtr<ScriptLibrary>& library);
 
 	private:
-		/**
-		 * @copydoc	ScriptManager::onShutDown
-		 */
+		/** @copydoc ScriptManager::onShutDown */
 		void onShutDown() override;
 
 		SPtr<ScriptLibrary> mScriptLibrary;
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsShapeMeshes2D.h

@@ -8,31 +8,34 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Helper class for easily creating common 2D shapes.
+	/** @addtogroup Utility-Engine
+	 *  @{
 	 */
+
+	/**	Helper class for easily creating common 2D shapes. */
 	class BS_EXPORT ShapeMeshes2D
 	{
 	public:
 		/**
-		 * @brief	Fills the mesh data with vertices representing a quad (2 triangles).
+		 * Fills the mesh data with vertices representing a quad (2 triangles).
 		 *
-		 * @param	area			Area in which to draw the quad.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	area			Area in which to draw the quad.
+		 * @param[in]	meshData		Mesh data that will be populated.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector2 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 4 vertices and 6 indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 * 	Vector2 VES_POSITION
+		 * 	32bit index buffer
+		 * 	Enough space for 4 vertices and 6 indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidQuad(const Rect2& area, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a per-pixel line.
+		 * Fills the mesh data with vertices representing a per-pixel line.
 		 *
 		 * @param	a				Start point of the line.
 		 * @param	b				End point of the line.
@@ -40,17 +43,20 @@ namespace BansheeEngine
 		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
 		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector2 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 2 vertices and 2 indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *	Vector2 VES_POSITION
+		 * 	32bit index buffer
+		 * 	Enough space for 2 vertices and 2 indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
-		static void pixelLine(const Vector2& a, const Vector2& b, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
+		static void pixelLine(const Vector2& a, const Vector2& b, const MeshDataPtr& meshData, UINT32 vertexOffset, 
+			UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing an anti-aliased line of specific width. Antialiasing is done using alpha blending.
+		 * Fills the mesh data with vertices representing an anti-aliased line of specific width. Antialiasing is done 
+		 * using alpha blending.
 		 *
 		 * @param	a				Start point of the line.
 		 * @param	b				End point of the line.
@@ -61,35 +67,40 @@ namespace BansheeEngine
 		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
 		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector2 VES_POSITION
-		 * 			  UINT32  VES_COLOR
-		 * 			  32bit index buffer
-		 *			  Enough space for 8 vertices and 30 indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector2 VES_POSITION
+		 *  UINT32  VES_COLOR
+		 *  32bit index buffer
+		 *	Enough space for 8 vertices and 30 indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
-		static void antialiasedLine(const Vector2& a, const Vector2& b, float width, float borderWidth, const Color& color, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
+		static void antialiasedLine(const Vector2& a, const Vector2& b, float width, float borderWidth, const Color& color,
+			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing per-pixel lines.
+		 * Fills the mesh data with vertices representing per-pixel lines.
 		 *
 		 * @param	linePoints		A list of start and end points for the lines. Must be a multiple of 2.
 		 * @param	meshData		Mesh data that will be populated.
 		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
 		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector2  VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for (numLines * 2) vertices and (numLines * 2) indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector2  VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for (numLines * 2) vertices and (numLines * 2) indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
-		static void pixelLineList(const Vector<Vector2>& linePoints, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
+		static void pixelLineList(const Vector<Vector2>& linePoints, const MeshDataPtr& meshData, UINT32 vertexOffset, 
+			UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing anti-aliased lines of specific width. Antialiasing is done using alpha blending.
+		 * Fills the mesh data with vertices representing anti-aliased lines of specific width. Antialiasing is done using
+		 * alpha blending.
 		 *
 		 * @param	linePoints		A list of start and end points for the lines. Must be a multiple of 2.
 		 * @param	width			Width of the line.
@@ -99,106 +110,106 @@ namespace BansheeEngine
 		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
 		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector2 VES_POSITION
-		 * 			  UINT32  VES_COLOR
-		 * 			  32bit index buffer
-		 *			  Enough space for (numLines * 8) vertices and (numLines * 30) indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector2 VES_POSITION
+		 *  UINT32  VES_COLOR
+		 *  32bit index buffer
+		 *	Enough space for (numLines * 8) vertices and (numLines * 30) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
-		static void antialiasedLineList(const Vector<Vector2>& linePoints, float width, float borderWidth, const Color& color, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
+		static void antialiasedLineList(const Vector<Vector2>& linePoints, float width, float borderWidth, 
+			const Color& color, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		static const UINT32 NUM_VERTICES_AA_LINE;
 		static const UINT32 NUM_INDICES_AA_LINE;
 	protected:
 		/**
-		 * @brief	Fills the provided buffers with vertices representing a per-pixel line.
+		 * Fills the provided buffers with vertices representing a per-pixel line.
 		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	a				Start point of the line.
+		 * @param[in]	b				End point of the line.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelLine(const Vector2& a, const Vector2& b, UINT8* outVertices,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing an antialiased line with a custom width.
+		 * Fills the provided buffers with vertices representing an antialiased line with a custom width.
 		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	width			Width of the line.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the line.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outColors		Output buffer that will store the vertex color data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	a				Start point of the line.
+		 * @param[in]	b				End point of the line.
+		 * @param[in]	width			Width of the line.
+		 * @param[in]	borderWidth		Width of the anti-aliased border.
+		 * @param[in]	color			Color of the line.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outColors		Output buffer that will store the vertex color data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
-		static void antialiasedLine(const Vector2& a, const Vector2& b, float width, float borderWidth, const Color& color, UINT8* outVertices, UINT8* outColors,
-			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
+		static void antialiasedLine(const Vector2& a, const Vector2& b, float width, float borderWidth, 
+			const Color& color, UINT8* outVertices, UINT8* outColors, UINT32 vertexOffset, UINT32 vertexStride, 
+			UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing an antialiased polygon.
+		 * Fills the provided buffers with vertices representing an antialiased polygon.
 		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the polygon.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outColors		Output buffer that will store the vertex color data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[in]	borderWidth		Width of the anti-aliased border.
+		 * @param[in]	color			Color of the polygon.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outColors		Output buffer that will store the vertex color data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
-		static void antialiasedPolygon(const Vector<Vector2>& points, float borderWidth, const Color& color, UINT8* outVertices, UINT8* outColors,
-			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
+		static void antialiasedPolygon(const Vector<Vector2>& points, float borderWidth, const Color& color, 
+			UINT8* outVertices, UINT8* outColors, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, 
+			UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with position data and indices representing an inner 
+		 * Fills the provided buffers with position data and indices representing an inner 
 		 *			area of a polygon (basically a normal non-antialiased polygon).
 		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelSolidPolygon(const Vector<Vector2>& points, UINT8* outVertices,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing a pixel-wide polygon border.
+		 * Fills the provided buffers with vertices representing a pixel-wide polygon border.
 		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outColors		Output buffer that will store the vertex color data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outColors		Output buffer that will store the vertex color data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelWirePolygon(const Vector<Vector2>& points, UINT8* outVertices, UINT8* outColors,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 	private:
-		/**
-		 * @brief	Converts an area with normalized ([0, 1] range) coordinates and returns
-		 *			area in clip space coordinates.
-		 */
+		/** Converts an area with normalized ([0, 1] range) coordinates and returns area in clip space coordinates. */
 		static Rect2 normalizedCoordToClipSpace(const Rect2& area);
 
-		/**
-		 * @brief	Converts a point with normalized ([0, 1] range) coordinates and returns
-		 *			a point in clip space coordinates.
-		 */
+		/** Converts a point with normalized ([0, 1] range) coordinates and returns a point in clip space coordinates. */
 		static Vector2 normalizedCoordToClipSpace(const Vector2& pos);
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsShapeMeshes3D.h

@@ -9,532 +9,532 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Helper class for easily creating common 3D shapes.
+	/** @addtogroup Utility-Engine
+	 *  @{
 	 */
+
+	/**	Helper class for easily creating common 3D shapes. */
 	class BS_EXPORT ShapeMeshes3D
 	{
 	public:
 		/**
-		 * @brief	Fills the mesh data with vertices representing an outline of axis aligned box.
+		 * Fills the mesh data with vertices representing an outline of axis aligned box.
 		 *
-		 * @param	aabox			Axis aligned box to create the mesh data for
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		aabox			Axis aligned box to create the mesh data for
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 8 vertices and 24 indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for 8 vertices and 24 indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void wireAABox(const AABox& box, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a solid axis aligned box.
+		 * Fills the mesh data with vertices representing a solid axis aligned box.
 		 *
-		 * @param	aabox			Axis aligned box to create the mesh data for
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		aabox			Axis aligned box to create the mesh data for
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for 24 vertices and 36 indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for 24 vertices and 36 indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidAABox(const AABox& box, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing an outline of a sphere.
-		 *
-		 * @param	sphere			Sphere to get the mesh data for
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the sphere will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 3 * ((quality + 1) * 5) vertices 
-		 *			  Enough space for 6 * ((quality + 1) * 5 - 1) indices
-		 *
-		 *			Primitives are output in the form of a line list.
-		 */
-		static void wireSphere(const Sphere& sphere, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
-
-		/**
-		 * @brief	Fills the mesh data with vertices representing a sphere.
-		 *
-		 * @param	sphere			Sphere to get the mesh data for
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the sphere will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for 20 * (4 * (3 ^ quality)) vertices 
-		 *			  Enough space for 20 * (4 * (3 ^ quality)) indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
-		 */
-		static void solidSphere(const Sphere& sphere, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 1);
-
-		/**
-		 * @brief	Fills the mesh data with vertices representing an outline of an arc.
-		 *
-		 * @param	center			Center of the arc to generate geometry for.
-		 * @param	radius			Radius of the arc to generate geometry for.
-		 * @param	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the normal.
-		 * @param	startAngle		Angle at which the arc starts.
-		 * @param	amountAngle		Angle that the arc spans.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the arc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for ((quality + 1) * 5) vertices 
-		 *			  Enough space for (((quality + 1) * 5 - 1) * 2) indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * Fills the mesh data with vertices representing an outline of a sphere.
+		 *
+		 * @param[in]		sphere			Sphere to get the mesh data for
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the sphere will have. Higher level means 
+		 *									higher quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for 3 * ((quality + 1) * 5) vertices 
+		 *	Enough space for 6 * ((quality + 1) * 5 - 1) indices
+		 * @note
+		 * Primitives are output in the form of a line list.
+		 */
+		static void wireSphere(const Sphere& sphere, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, 
+			UINT32 quality = 10);
+
+		/**
+		 * Fills the mesh data with vertices representing a sphere.
+		 *
+		 * @param[in]		sphere			Sphere to get the mesh data for
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the sphere will have. Higher level means 
+		 *									higher quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for 20 * (4 * (3 ^ quality)) vertices 
+		 *	Enough space for 20 * (4 * (3 ^ quality)) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
+		 */
+		static void solidSphere(const Sphere& sphere, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, 
+			UINT32 quality = 1);
+
+		/**
+		 * Fills the mesh data with vertices representing an outline of an arc.
+		 *
+		 * @param[in]		center			Center of the arc to generate geometry for.
+		 * @param[in]		radius			Radius of the arc to generate geometry for.
+		 * @param[in]		normal			Normal around which the arc is generated. Arc geometry will be perpendicular
+		 *									to the normal.
+		 * @param[in]		startAngle		Angle at which the arc starts.
+		 * @param[in]		amountAngle		Angle that the arc spans.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the arc will have. Higher level means
+		 *									higher quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for ((quality + 1) * 5) vertices 
+		 *	Enough space for (((quality + 1) * 5 - 1) * 2) indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void wireArc(const Vector3& center, float radius, const Vector3& normal, Degree startAngle, Degree amountAngle,
 			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a solid double-sided arc.
-		 *
-		 * @param	center			Center of the arc to generate geometry for.
-		 * @param	radius			Radius of the arc to generate geometry for.
-		 * @param	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the normal.
-		 * @param	startAngle		Angle at which the arc starts.
-		 * @param	amountAngle		Angle that the arc spans.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the arc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for ((quality + 1) * 5 + 1) * 2 vertices 
-		 *			  Enough space for (((quality + 1) * 5 - 1) * 6) indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * Fills the mesh data with vertices representing a solid double-sided arc.
+		 *
+		 * @param[in]		center			Center of the arc to generate geometry for.
+		 * @param[in]		radius			Radius of the arc to generate geometry for.
+		 * @param[in]		normal			Normal around which the arc is generated. Arc geometry will be perpendicular to
+		 *									the normal.
+		 * @param[in]		startAngle		Angle at which the arc starts.
+		 * @param[in]		amountAngle		Angle that the arc spans.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the arc will have. Higher level means higher 
+		 *									quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for ((quality + 1) * 5 + 1) * 2 vertices 
+		 *	Enough space for (((quality + 1) * 5 - 1) * 6) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidArc(const Vector3& center, float radius, const Vector3& normal, Degree startAngle, Degree amountAngle,
 			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing an outline of a disc.
-		 *
-		 * @param	center			Center of the disc to generate geometry for.
-		 * @param	radius			Radius of the disc to generate geometry for.
-		 * @param	normal			Normal around which the disc is generated. Disc geometry will be perpendicular to the normal.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the disc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for ((quality + 1) * 5) vertices 
-		 *			  Enough space for (((quality + 1) * 5 - 1) * 2) indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * Fills the mesh data with vertices representing an outline of a disc.
+		 *
+		 * @param[in]		center			Center of the disc to generate geometry for.
+		 * @param[in]		radius			Radius of the disc to generate geometry for.
+		 * @param[in]		normal			Normal around which the disc is generated. Disc geometry will be perpendicular
+		 *									to the normal.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the disc will have. Higher level means
+		 *									higher quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 * 	Vector3 VES_POSITION
+		 * 	32bit index buffer
+		 * 	Enough space for ((quality + 1) * 5) vertices 
+		 *	Enough space for (((quality + 1) * 5 - 1) * 2) indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void wireDisc(const Vector3& center, float radius, const Vector3& normal, const MeshDataPtr& meshData,
 			UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a solid double-sided disc.
-		 *
-		 * @param	center			Center of the disc to generate geometry for.
-		 * @param	radius			Radius of the disc to generate geometry for.
-		 * @param	normal			Normal around which the disc is generated. Disc geometry will be perpendicular to the normal.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the disc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for ((quality + 1) * 5 + 1) * 2 vertices 
-		 *			  Enough space for (((quality + 1) * 5 - 1) * 6) indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * Fills the mesh data with vertices representing a solid double-sided disc.
+		 *
+		 * @param[in]		center			Center of the disc to generate geometry for.
+		 * @param[in]		radius			Radius of the disc to generate geometry for.
+		 * @param[in]		normal			Normal around which the disc is generated. Disc geometry will be perpendicular 
+		 *									to the normal.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the disc will have. Higher level means higher
+		 *									quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for ((quality + 1) * 5 + 1) * 2 vertices 
+		 *	Enough space for (((quality + 1) * 5 - 1) * 6) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidDisc(const Vector3& center, float radius, const Vector3& normal, const MeshDataPtr& meshData,
 			UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing an outline of an camera frustum. Frustum will
-		 *			be facing -z and be positioned at world origin.
-		 *
-		 * @param	position		Starting point for the frustum.
-		 * @param	aspect			Aspect ratio (width / height).
-		 * @param	FOV				Horizontal field of view angle.
-		 * @param	near			Distance to near clipping plane.
-		 * @param	far				Distance to far clipping plane.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 8 vertices and 24 indices
+		 * Fills the mesh data with vertices representing an outline of an camera frustum. Frustum will be facing -z and be
+		 * positioned at world origin.
 		 *
-		 *			Primitives are output in the form of a line list.
+		 * @param[in]		position		Starting point for the frustum.
+		 * @param[in]		aspect			Aspect ratio (width / height).
+		 * @param[in]		FOV				Horizontal field of view angle.
+		 * @param[in]		near			Distance to near clipping plane.
+		 * @param[in]		far				Distance to far clipping plane.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * 							
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for 8 vertices and 24 indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void wireFrustum(const Vector3& position, float aspect, Degree FOV, float near, float far,
 			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a solid cone.
-		 *
-		 * @param	base			World position of the cone base.
-		 * @param	normal			Direction of the pointed part of the cone.
-		 * @param	height			Cone height (distance from base to the top).
-		 * @param	radius			Cone radius (distance from base center to outer edge).
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the cone will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
-		 *
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for ((quality + 1) * 4 + 1) * 2 vertices 
-		 *			  Enough space for (((quality + 1) * 4 - 1) * 6) indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * Fills the mesh data with vertices representing a solid cone.
+		 *
+		 * @param[in]		base			World position of the cone base.
+		 * @param[in]		normal			Direction of the pointed part of the cone.
+		 * @param[in]		height			Cone height (distance from base to the top).
+		 * @param[in]		radius			Cone radius (distance from base center to outer edge).
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		quality			Represents the level of tessellation the cone will have. Higher level means 
+		 *									higher quality but also more vertices and primitives.
+		 *
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for ((quality + 1) * 4 + 1) * 2 vertices 
+		 *	Enough space for (((quality + 1) * 4 - 1) * 6) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidCone(const Vector3& base, const Vector3& normal, float height, float radius,
 			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset, UINT32 quality = 10);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a quad (4 triangles, two sided).
+		 * Fills the mesh data with vertices representing a quad (4 triangles, two sided).
 		 *
-		 * @param	area			Area in which to draw the quad.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		area			Area in which to draw the quad.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 *			  Vector3 VES_NORMAL
-		 * 			  32bit index buffer
-		 * 			  Enough space for 8 vertices and 12 indices
-		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *	Vector3 VES_NORMAL
+		 * 	32bit index buffer
+		 * 	Enough space for 8 vertices and 12 indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void solidQuad(const Rect3& area, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing a per-pixel line.
+		 * Fills the mesh data with vertices representing a per-pixel line.
 		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		a				Start point of the line.
+		 * @param[in]		b				End point of the line.
+		 * @param[in, out]	meshData	Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3	  VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for 2 vertices and 2 indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3	  VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for 2 vertices and 2 indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void pixelLine(const Vector3& a, const Vector3& b, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing an anti-aliased line of specific width. Antialiasing is done using alpha blending.
-		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	up				Up direction to which the line will run perpendicular to.
-		 * @param	width			Width of the line.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the line.
-		 * @param	meshData		Mesh data that will be populated by this method.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  UINT32  VES_COLOR
-		 * 			  32bit index buffer
-		 *			  Enough space for 8 vertices and 30 indices
+		 * Fills the mesh data with vertices representing an anti-aliased line of specific width. Antialiasing is done 
+		 * using alpha blending.
 		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @param[in]		a				Start point of the line.
+		 * @param[in]		b				End point of the line.
+		 * @param[in]		up				Up direction to which the line will run perpendicular to.
+		 * @param[in]		width			Width of the line.
+		 * @param[in]		borderWidth		Width of the anti-aliased border.
+		 * @param[in]		color			Color of the line.
+		 * @param[in, out]	meshData	Mesh data that will be populated by this method.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * 							
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  UINT32  VES_COLOR
+		 *  32bit index buffer
+		 *	Enough space for 8 vertices and 30 indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void antialiasedLine(const Vector3& a, const Vector3& b, const Vector3& up, float width, float borderWidth, const Color& color,
 			const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing per-pixel lines.
+		 * Fills the mesh data with vertices representing per-pixel lines.
 		 *
-		 * @param	linePoints		A list of start and end points for the lines. Must be a multiple of 2.
-		 * @param	meshData		Mesh data that will be populated.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]		linePoints		A list of start and end points for the lines. Must be a multiple of 2.
+		 * @param[in, out]	meshData		Mesh data that will be populated.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3  VES_POSITION
-		 * 			  32bit index buffer
-		 * 			  Enough space for (numLines * 2) vertices and (numLines * 2) indices
-		 *
-		 *			Primitives are output in the form of a line list.
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3  VES_POSITION
+		 *  32bit index buffer
+		 *  Enough space for (numLines * 2) vertices and (numLines * 2) indices
+		 * @note
+		 * Primitives are output in the form of a line list.
 		 */
 		static void pixelLineList(const Vector<Vector3>& linePoints, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the mesh data with vertices representing anti-aliased lines of specific width. Antialiasing is done using alpha blending.
-		 *
-		 * @param	linePoints		A list of start and end points for the lines. Must be a multiple of 2.
-		 * @param	up				Up direction to which the line will run perpendicular to.
-		 * @param	width			Width of the line.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the line.
-		 * @param	meshData		Mesh data that will be populated by this method.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * 							
-		 * @note	Provided MeshData must have some specific elements at least:
-		 * 			  Vector3 VES_POSITION
-		 * 			  UINT32  VES_COLOR
-		 * 			  32bit index buffer
-		 *			  Enough space for (numLines * 8) vertices and (numLines * 30) indices
+		 * Fills the mesh data with vertices representing anti-aliased lines of specific width. Antialiasing is done using
+		 * alpha blending.
 		 *
-		 *			Primitives are output in the form of a triangle list.
+		 * @param[in]		linePoints		A list of start and end points for the lines. Must be a multiple of 2.
+		 * @param[in]		up				Up direction to which the line will run perpendicular to.
+		 * @param[in]		width			Width of the line.
+		 * @param[in]		borderWidth		Width of the anti-aliased border.
+		 * @param[in]		color			Color of the line.
+		 * @param[in, out]	meshData		Mesh data that will be populated by this method.
+		 * @param[in]		vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]		indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * 							
+		 * @note	
+		 * Provided MeshData must have some specific elements at least:
+		 *  Vector3 VES_POSITION
+		 *  UINT32  VES_COLOR
+		 *  32bit index buffer
+		 *	Enough space for (numLines * 8) vertices and (numLines * 30) indices
+		 * @note
+		 * Primitives are output in the form of a triangle list.
 		 */
 		static void antialiasedLineList(const Vector<Vector3>& linePoints, const Vector3& up, float width, float borderWidth,
 			const Color& color, const MeshDataPtr& meshData, UINT32 vertexOffset, UINT32 indexOffset);
 
-/**
-		 * @brief	Fills the provided buffers with position and index data representing an outline of an axis aligned box.
-		 * 			Use ::getNumElementsWireAABox todetermine the required sizes of the output buffers.
+		/**
+		 * Fills the provided buffers with position and index data representing an outline of an axis aligned box. Use 
+		 * getNumElementsWireAABox() to determine the required sizes of the output buffers.
 		 *
-		 * @param	box				Box to create geometry for.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes.
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	box				Box to create geometry for.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes.
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void wireAABox(const AABox& box, UINT8* outVertices, UINT32 vertexOffset, UINT32 vertexStride,
 			UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing a solid axis aligned box.
-		 * 			Use ::getNumElementsAABox todetermine the required sizes of the output buffers.
-		 *
-		 * @param	box				Box to create geometry for.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with position and index data representing a solid axis aligned box. Use 
+		 * getNumElementsAABox() to determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	box				Box to create geometry for.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void solidAABox(const AABox& box, UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride,
 			UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing a sphere.
-		 * 			Use ::getNumElementsSphere todetermine the required sizes of the output buffers.
-		 *
-		 * @param	sphere			Sphere to create geometry for.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	outNormals		Pre-allocated output buffer that will store the vertex normal data. Can be null if normals aren't needed.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the sphere will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
+		 * Fills the provided buffers with position and index data representing a sphere. Use getNumElementsSphere() to
+		 * determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	sphere			Sphere to create geometry for.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[out]	outNormals		Pre-allocated output buffer that will store the vertex normal data. Can be null if
+		 *								normals aren't needed.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	quality			Represents the level of tessellation the sphere will have. Higher level means higher
+		 *								quality but also more vertices and primitives.
 		 */
 		static void solidSphere(const Sphere& sphere, UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride,
 			UINT32* outIndices, UINT32 indexOffset, UINT32 quality);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing an outline of an arc. 
-		 * 			Use ::getNumElementWiresArc to determine the required sizes of the output buffers.
-		 *
-		 * @param	center			Center of the arc to generate geometry for.
-		 * @param	radius			Radius of the arc to generate geometry for.
-		 * @param	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the normal.
-		 * @param	startAngle		Angle at which the arc starts.
-		 * @param	amountAngle		Angle that the arc spans.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes.
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the arc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
+		 * Fills the provided buffers with position and index data representing an outline of an arc. Use
+		 * getNumElementWiresArc() to determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	center			Center of the arc to generate geometry for.
+		 * @param[in]	radius			Radius of the arc to generate geometry for.
+		 * @param[in]	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the
+		 *								normal.
+		 * @param[in]	startAngle		Angle at which the arc starts.
+		 * @param[in]	amountAngle		Angle that the arc spans.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes.
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	quality			Represents the level of tessellation the arc will have. Higher level means higher
+		 *								quality but also more vertices and primitives.
 		 */
 		static void wireArc(const Vector3& center, float radius, const Vector3& normal, Degree startAngle, Degree amountAngle,
 			UINT8* outVertices, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset, UINT32 quality);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing a solid arc. 
-		 * 			Use ::getNumElementsArc to determine the required sizes of the output buffers.
-		 *
-		 * @param	center			Center of the arc to generate geometry for.
-		 * @param	radius			Radius of the arc to generate geometry for.
-		 * @param	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the normal.
-		 * @param	startAngle		Angle at which the arc starts.
-		 * @param	amountAngle		Angle that the arc spans.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	outNormals		Pre-allocated output buffer that will store the vertex normal data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the arc will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
+		 * Fills the provided buffers with position and index data representing a solid arc. Use getNumElementsArc() to
+		 * determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	center			Center of the arc to generate geometry for.
+		 * @param[in]	radius			Radius of the arc to generate geometry for.
+		 * @param[in]	normal			Normal around which the arc is generated. Arc geometry will be perpendicular to the
+		 *								normal.
+		 * @param[in]	startAngle		Angle at which the arc starts.
+		 * @param[in]	amountAngle		Angle that the arc spans.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[out]	outNormals		Pre-allocated output buffer that will store the vertex normal data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	quality			Represents the level of tessellation the arc will have. Higher level means higher
+		 *								quality but also more vertices and primitives.
 		 */
 		static void solidArc(const Vector3& center, float radius, const Vector3& normal, Degree startAngle, Degree amountAngle,
 			UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset, UINT32 quality);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing an outline of a camera frustum.
-		 * 			Use ::getNumElementsFrustum to determine the required sizes of the output buffers.
-		 *
-		 * @param	position		Starting point for the frustum.
-		 * @param	aspect			Aspect ratio (width / height).
-		 * @param	FOV				Horizontal field of view angle.
-		 * @param	near			Distance to near clipping plane.
-		 * @param	far				Distance to far clipping plane.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes.
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with position and index data representing an outline of a camera frustum. Use
+		 * getNumElementsFrustum() to determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	position		Starting point for the frustum.
+		 * @param[in]	aspect			Aspect ratio (width / height).
+		 * @param[in]	FOV				Horizontal field of view angle.
+		 * @param[in]	near			Distance to near clipping plane.
+		 * @param[in]	far				Distance to far clipping plane.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes.
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void wireFrustum(const Vector3& position, float aspect, Degree FOV, float near, float far,
 			UINT8* outVertices, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing a solid cone.
-		 * 			Use ::getNumElementsCone to determine the required sizes of the output buffers.
-		 *
-		 * @param	base			World position of the cone base.
-		 * @param	normal			Direction of the pointed part of the cone.
-		 * @param	height			Cone height (distance from base to the top).
-		 * @param	radius			Cone radius (distance from base center to outer edge).
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	outNormals		Pre-allocated output buffer that will store the vertex normal data. Can be null if normals aren't needed.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
-		 * @param	quality			Represents the level of tessellation the cone will have. Higher level means higher quality
-		 *							but also more vertices and primitives.
+		 * Fills the provided buffers with position and index data representing a solid cone. Use getNumElementsCone() to
+		 * determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	base			World position of the cone base.
+		 * @param[in]	normal			Direction of the pointed part of the cone.
+		 * @param[in]	height			Cone height (distance from base to the top).
+		 * @param[in]	radius			Cone radius (distance from base center to outer edge).
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[out]	outNormals		Pre-allocated output buffer that will store the vertex normal data. Can be null if
+		 *								normals aren't needed.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * @param[in]	quality			Represents the level of tessellation the cone will have. Higher level means higher
+		 *								quality but also more vertices and primitives.
 		 */
 		static void solidCone(const Vector3& base, const Vector3& normal, float height, float radius,
 			UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset, UINT32 quality);
 
 		/**
-		 * @brief	Fills the provided buffers with position and index data representing a solid quad.
-		 * 			Use ::getNumElementsCone to determine the required sizes of the output buffers.
-		 *
-		 * @param	area			Area covered by the quad.
-		 * @param	outVertices		Pre-allocated output buffer that will store the vertex position data.
-		 * @param	outNormals		Pre-allocated output buffer that will store the vertex normal data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
-		 * @param	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with position and index data representing a solid quad. Use getNumElementsCone() to
+		 * determine the required sizes of the output buffers.
+		 *
+		 * @param[in]	area			Area covered by the quad.
+		 * @param[out]	outVertices		Pre-allocated output buffer that will store the vertex position data.
+		 * @param[out]	outNormals		Pre-allocated output buffer that will store the vertex normal data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and normal buffer)
+		 * @param[out]	outIndices		Pre-allocated output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void solidQuad(const Rect3& area, UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a solid axis aligned box.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a solid axis aligned box. */
 		static void getNumElementsAABox(UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a wireframe axis aligned box.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a wireframe axis aligned box. */
 		static void getNumElementsWireAABox(UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a solid sphere
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a solid sphere of the specified quality. */
 		static void getNumElementsSphere(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a wire sphere
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a wire sphere of the specified quality. */
 		static void getNumElementsWireSphere(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a solid arc
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a solid arc of the specified quality. */
 		static void getNumElementsArc(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a wire arc
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a wire arc of the specified quality. */
 		static void getNumElementsWireArc(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a solid desc
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a solid desc	of the specified quality. */
 		static void getNumElementsDisc(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a wire disc
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a wire disc of the specified quality. */
 		static void getNumElementsWireDisc(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a cone
-		 *			of the specified quality.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a cone of the specified quality. */
 		static void getNumElementsCone(UINT32 quality, UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a frustum.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a frustum. */
 		static void getNumElementsFrustum(UINT32& numVertices, UINT32& numIndices);
 
-		/**
-		 * @brief	Calculates number of vertices and indices required for geometry of a quadrirateral.
-		 */
+		/**	Calculates number of vertices and indices required for geometry of a quadrirateral. */
 		static void getNumElementsQuad(UINT32& numVertices, UINT32& numIndices);
 
 		static const UINT32 NUM_VERTICES_AA_LINE;
@@ -542,128 +542,131 @@ namespace BansheeEngine
 
 	protected:
 		/**
-		 * @brief	Fills the provided buffers with vertices representing a per-pixel line.
-		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with vertices representing a per-pixel line.
+		 *
+		 * @param[in]	a				Start point of the line.
+		 * @param[in]	b				End point of the line.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelLine(const Vector3& a, const Vector3& b, UINT8* outVertices,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing an antialiased line with a custom width.
-		 *
-		 * @param	a				Start point of the line.
-		 * @param	b				End point of the line.
-		 * @param	up				Up direction to which the line will run perpendicular to.
-		 * @param	width			Width of the line.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the line.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outColors		Output buffer that will store the vertex color data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with vertices representing an antialiased line with a custom width.
+		 *
+		 * @param[in]	a				Start point of the line.
+		 * @param[in]	b				End point of the line.
+		 * @param[in]	up				Up direction to which the line will run perpendicular to.
+		 * @param[in]	width			Width of the line.
+		 * @param[in]	borderWidth		Width of the anti-aliased border.
+		 * @param[in]	color			Color of the line.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outColors		Output buffer that will store the vertex color data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
-		static void antialiasedLine(const Vector3& a, const Vector3& b, const Vector3& up, float width, float borderWidth, const Color& color, UINT8* outVertices, UINT8* outColors,
-			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
+		static void antialiasedLine(const Vector3& a, const Vector3& b, const Vector3& up, float width, float borderWidth, 
+			const Color& color, UINT8* outVertices, UINT8* outColors, UINT32 vertexOffset, UINT32 vertexStride, 
+			UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with position data and indices representing an inner 
-		 *			area of a polygon (basically a normal non-antialiased polygon).
-		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with position data and indices representing an inner area of a polygon (basically a
+		 * normal non-antialiased polygon).
+		 *
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelSolidPolygon(const Vector<Vector3>& points, UINT8* outVertices,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing a pixel-wide polygon border.
-		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with vertices representing a pixel-wide polygon border.
+		 *
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void pixelWirePolygon(const Vector<Vector3>& points, UINT8* outVertices,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 		/**
-		 * @brief	Fills the provided buffers with vertices representing an antialiased polygon.
-		 *
-		 * @param	points			Points defining the polygon. First point is assumed to be the start and end point.
-		 * @param	up				Up direction to which the polygon will run perpendicular to.
-		 * @param	borderWidth		Width of the anti-aliased border.
-		 * @param	color			Color of the polygon.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outColors		Output buffer that will store the vertex color data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 * @param	outIndices		Output buffer that will store the index data. Indices are 32bit.
-		 * @param	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
+		 * Fills the provided buffers with vertices representing an antialiased polygon.
+		 *
+		 * @param[in]	points			Points defining the polygon. First point is assumed to be the start and end point.
+		 * @param[in]	up				Up direction to which the polygon will run perpendicular to.
+		 * @param[in]	borderWidth		Width of the anti-aliased border.
+		 * @param[in]	color			Color of the polygon.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outColors		Output buffer that will store the vertex color data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @param[out]	outIndices		Output buffer that will store the index data. Indices are 32bit.
+		 * @param[in]	indexOffset 	Offset in number of indices from the start of the buffer to start writing at.
 		 */
 		static void antialiasedPolygon(const Vector<Vector3>& points, const Vector3& up, float borderWidth, const Color& color, UINT8* outVertices, UINT8* outColors,
 			UINT32 vertexOffset, UINT32 vertexStride, UINT32* outIndices, UINT32 indexOffset);
 
 	private:
 		/**
-		 * @brief	Calculates the center of the provided vertices.
+		 * Calculates the center of the provided vertices.
 		 * 
-		 * @param	vertices		Buffer containing vertices. Vertices must be of three dimensions at least.
-		 * @param	numVertices		Number of vertices to calculate the center for.
-		 * @param	vertexStride	Number of bytes between two vertices in the buffer.
-		 *
-		 * @returns	Center point of the vertices.
+		 * @param[in]	vertices		Buffer containing vertices. Vertices must be of three dimensions at least.
+		 * @param[in]	numVertices		Number of vertices to calculate the center for.
+		 * @param[in]	vertexStride	Number of bytes between two vertices in the buffer.
+		 * @return					Center point of the vertices.
 		 */
 		static Vector3 calcCenter(UINT8* vertices, UINT32 numVertices, UINT32 vertexStride);
 
 		/**
-		 * @brief	Subdivides the provided triangle so it approximates a curved surface of a sphere.
-		 *
-		 * @param	center			Center of the sphere to approximate.
-		 * @param	radius			Radius of the sphere to approximate.
-		 * @param	numLevels		Number of times to subdivide the triangle. Higher number means better approximation.
-		 * @param	a				First corner of the triangle. Must be normalized.
-		 * @param	b				Second corner of the triangle. Must be normalized.
-		 * @param	c				Third corner of the triangle. Must be normalized.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	outNormals		Output buffer that will store the vertex normal data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
-		 *
-		 * @returns	Number of vertices generated (3 * (4 ^ numLevels)).
+		 * Subdivides the provided triangle so it approximates a curved surface of a sphere.
+		 *
+		 * @param[in]	center			Center of the sphere to approximate.
+		 * @param[in]	radius			Radius of the sphere to approximate.
+		 * @param[in]	numLevels		Number of times to subdivide the triangle. Higher number means better approximation.
+		 * @param[in]	a				First corner of the triangle. Must be normalized.
+		 * @param[in]	b				Second corner of the triangle. Must be normalized.
+		 * @param[in]	c				Third corner of the triangle. Must be normalized.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[out]	outNormals		Output buffer that will store the vertex normal data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * @return						Number of vertices generated (3 * (4 ^ numLevels)).
 		 */
 		static UINT32 subdivideTriangleOnSphere(const Vector3& center, float radius, UINT32 numLevels,
 			const Vector3& a, const Vector3& b, const Vector3& c,
 			UINT8* outVertices, UINT8* outNormals, UINT32 vertexOffset, UINT32 vertexStride);
 
 		/**
-		 * @brief	Generates vertices that are part of an arc approximation.
-		 *
-		 * @param	center		Determines world position of the arc.
-		 * @param	up			Determines rotation of the arc. Arc vertices will be perpendicular to this direction.
-		 * @param	radius		Distance of arc vertices from the center.
-		 * @param	startAngle	Angle in degrees to start the arc at.
-		 * @param	angleAmount	Angle in degrees to extend the arc from the start angle.
-		 * @param	numVertices	Number of vertices to generate for the arc. Higher number means better arc approximation. Must be 2 or higher.
-		 * @param	outVertices		Output buffer that will store the vertex position data.
-		 * @param	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
-		 * @param	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
+		 * Generates vertices that are part of an arc approximation.
+		 *
+		 * @param[in]	center			Determines world position of the arc.
+		 * @param[in]	up				Determines rotation of the arc. Arc vertices will be perpendicular to this 
+		 *								direction.
+		 * @param[in]	radius			Distance of arc vertices from the center.
+		 * @param[in]	startAngle		Angle in degrees to start the arc at.
+		 * @param[in]	angleAmount		Angle in degrees to extend the arc from the start angle.
+		 * @param[in]	numVertices		Number of vertices to generate for the arc. Higher number means better arc 
+		 *								approximation. Must be 2 or higher.
+		 * @param[out]	outVertices		Output buffer that will store the vertex position data.
+		 * @param[in]	vertexOffset	Offset in number of vertices from the start of the buffer to start writing at.
+		 * @param[in]	vertexStride	Size of a single vertex, in bytes. (Same for both position and color buffer)
 		 */
-		static void generateArcVertices(const Vector3& center, const Vector3& up, float radius, Degree startAngle, Degree angleAmount, UINT32 numVertices,
-			UINT8* outvertices, UINT32 vertexOffset, UINT32 vertexStride);
+		static void generateArcVertices(const Vector3& center, const Vector3& up, float radius, Degree startAngle, 
+			Degree angleAmount, UINT32 numVertices, UINT8* outvertices, UINT32 vertexOffset, UINT32 vertexStride);
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsSplashScreen.h

@@ -6,6 +6,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Platform-Engine
+	 *  @{
+	 */
+
 	/**	Displays a splash screen with Banshee Engine logo. */
 	class BS_EXPORT SplashScreen
 	{
@@ -28,4 +32,6 @@ namespace BansheeEngine
 
 		static const UINT32 SPLASH_SCREEN_DURATION_MS;
 	};
+
+	/** @} */
 }

BansheeEngine/Include/BsSpriteTextureRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond INTERNAL */
+	/** @addtogroup RTTI-Impl-Engine
+	 *  @{
+	 */
+
 	class BS_EXPORT SpriteTextureRTTI : public RTTIType<SpriteTexture, Resource, SpriteTextureRTTI>
 	{
 	private:
@@ -28,20 +33,23 @@ namespace BansheeEngine
 			addPlainField("mUVScale", 2, &SpriteTextureRTTI::getUVScale, &SpriteTextureRTTI::setUVScale);
 		}
 
-		virtual const String& getRTTIName() override
+		const String& getRTTIName() override
 		{
 			static String name = "SpriteTexture";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId() override
+		UINT32 getRTTIId() override
 		{
 			return TID_SpriteTexture;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject() override
+		std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return SpriteTexture::createEmpty();
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheeEngine/Include/BsVirtualInput.h

@@ -8,16 +8,17 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Input-Engine
+	 *  @{
+	 */
+
 	/**
-	 * @brief	Handles virtual input that allows you to receive virtual input events that 
-	 *			hide the actual physical input, allowing you to easily change the input keys
-	 *			while being transparent to the external code.
+	 * Handles virtual input that allows you to receive virtual input events that hide the actual physical input, allowing
+	 * you to easily change the input keys while being transparent to the external code.
 	 */
 	class BS_EXPORT VirtualInput : public Module<VirtualInput>
 	{
-		/**
-		 * @brief	Possible states of virtual buttons.
-		 */
+		/**	Possible states of virtual buttons. */
 		enum class ButtonState
 		{
 			Off,
@@ -26,9 +27,7 @@ namespace BansheeEngine
 			ToggledOff
 		};
 
-		/**
-		 * @brief	Data container for a single virtual button.
-		 */
+		/**	Data container for a single virtual button. */
 		struct ButtonData
 		{
 			VirtualButton button;
@@ -38,17 +37,13 @@ namespace BansheeEngine
 			bool allowRepeat;
 		};
 
-		/**
-		 * @brief	Contains button data for a specific input device.
-		 */
+		/**	Contains button data for a specific input device. */
 		struct DeviceData
 		{
 			Map<UINT32, ButtonData> cachedStates;
 		};
 
-		/**
-		 * @brief	Data container for a virtual button event.
-		 */
+		/**	Data container for a virtual button event. */
 		struct VirtualButtonEvent
 		{
 			VirtualButton button;
@@ -59,90 +54,71 @@ namespace BansheeEngine
 	public:
 		VirtualInput();
 
-		/**
-		 * @brief	Creates a new empty input configuration.
-		 */
-		static std::shared_ptr<InputConfiguration> createConfiguration();
+		/**	Creates a new empty input configuration. */
+		static SPtr<InputConfiguration> createConfiguration();
 
-		/**
-		 * @brief	Sets an input configuration that determines how physical keys map to virtual buttons.
-		 */
-		void setConfiguration(const std::shared_ptr<InputConfiguration>& input);
+		/**	Sets an input configuration that determines how physical keys map to virtual buttons. */
+		void setConfiguration(const SPtr<InputConfiguration>& input);
 
-		/**
-		 * @brief	Retrieves the active input configuration that determines how physical keys map to virtual buttons.
-		 */
-		std::shared_ptr<InputConfiguration> getConfiguration() const { return mInputConfiguration; }
+		/**	Retrieves the active input configuration that determines how physical keys map to virtual buttons. */
+		SPtr<InputConfiguration> getConfiguration() const { return mInputConfiguration; }
 
 		/**
-		 * @brief	Check is the virtual button just getting pressed. This state is only
-		 *			active for one frame.
+		 * Check is the virtual button just getting pressed. This state is only active for one frame.
 		 *
-		 * @param	button		Virtual button identifier.
-		 * @param	deviceIdx	Optional device index in case multiple input devices are available.
+		 * @param[in]	button		Virtual button identifier.
+		 * @param[in]	deviceIdx	Optional device index in case multiple input devices are available.
 		 */
 		bool isButtonDown(const VirtualButton& button, UINT32 deviceIdx = 0) const;
 
 		/**
-		 * @brief	Check is the virtual button just getting released. This state is only
-		 *			active for one frame.
+		 * Check is the virtual button just getting released. This state is only active for one frame.
 		 *
-		 * @param	button		Virtual button identifier.
-		 * @param	deviceIdx	Optional device index in case multiple input devices are available.
+		 * @param[in]	button		Virtual button identifier.
+		 * @param[in]	deviceIdx	Optional device index in case multiple input devices are available.
 		 */
 		bool isButtonUp(const VirtualButton& button, UINT32 deviceIdx = 0) const;
 
 		/**
-		 * @brief	Check is the virtual button is being held. This state is active as long
-		 *			as the button is being held down, i.e. possibly multiple frames.
+		 * Check is the virtual button is being held. This state is active as long as the button is being held down, 
+		 * i.e. possibly multiple frames.
 		 *
-		 * @param	button		Virtual button identifier.
-		 * @param	deviceIdx	Optional device index in case multiple input devices are available.
+		 * @param[in]	button		Virtual button identifier.
+		 * @param[in]	deviceIdx	Optional device index in case multiple input devices are available.
 		 */
 		bool isButtonHeld(const VirtualButton& button, UINT32 deviceIdx = 0) const;
 
 		/**
-		 * @brief	Returns normalized value for the specified input axis. 
-		 *			Returned value will usually be in [-1.0, 1.0] range, but can be outside
-		 *			the range for devices with unbound axes (e.g. mouse).
+		 * Returns normalized value for the specified input axis. Returned value will usually be in [-1.0, 1.0] range, but
+		 * can be outside the range for devices with unbound axes (e.g. mouse).
 		 *
-		 * @param	axis		Virtual axis identifier.
-		 * @param	deviceIdx	Optional device index in case multiple input devices are available.
+		 * @param[in]	axis		Virtual axis identifier.
+		 * @param[in]	deviceIdx	Optional device index in case multiple input devices are available.
 		 */
 		float getAxisValue(const VirtualAxis& axis, UINT32 deviceIdx = 0) const;
 
-		/**
-		 * @brief	Called once every frame.
-		 *
-		 * @note	Internal method.
-		 */
-		void _update();
-
-		/**
-		 * @brief	Triggered when a virtual button is pressed.
-		 */
+		/**	Triggered when a virtual button is pressed. */
 		Event<void(const VirtualButton&, UINT32 deviceIdx)> onButtonDown;
 
-		/**
-		 * @brief	Triggered when a virtual button is released.
-		 */
+		/**	Triggered when a virtual button is released. */
 		Event<void(const VirtualButton&, UINT32 deviceIdx)> onButtonUp;
 
-		/**
-		 * @brief	Triggered every frame when a virtual button is being held down.
-		 */
+		/**	Triggered every frame when a virtual button is being held down. */
 		Event<void(const VirtualButton&, UINT32 deviceIdx)> onButtonHeld;
+
+		/** @cond INTERNAL */
+
+		/** Called once every frame. Triggers button callbacks. */
+		void _update();
+
+		/** @endcond */
 	private:
 		friend class VirtualButton;
 
-		/**
-		 * @brief  Performs all logic related to a button press.
-		 */
+		/** Performs all logic related to a button press. */
 		void buttonDown(const ButtonEvent& event);
 
-		/**
-		 * @brief  Performs all logic related to a button release.
-		 */
+		/** Performs all logic related to a button release. */
 		void buttonUp(const ButtonEvent& event);
 
 		std::shared_ptr<InputConfiguration> mInputConfiguration;
@@ -155,8 +131,8 @@ namespace BansheeEngine
 		Vector<VIRTUAL_BUTTON_DESC> tempBtnDescs;
 	};
 
-	/**
-	 * @copydoc	VirtualInput
-	 */
+	/** Provides easier access to VirtualInput. */
 	BS_EXPORT VirtualInput& gVirtualInput();
+
+	/** @} */
 }