Documentation

BansheeCore/Include/BsComponent.h

@@ -6,7 +6,7 @@
 namespace BansheeEngine
 {
 	/**
-	 * @brief	Components represent primarily logic elements in the scene. 
+	 * @brief	Components represent primary logic elements in the scene. 
 	 *			They are attached to scene objects.
 	 */
 	class BS_CORE_EXPORT Component : public GameObject

BansheeEngine/Include/BsCamera.h

@@ -49,7 +49,7 @@ namespace BansheeEngine
 		/**
 		 * @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.
+		 *			horizontal FOV and the aspect ratio.
 		 */
         virtual void setHorzFOV(const Radian& fovy);
 
@@ -151,7 +151,7 @@ namespace BansheeEngine
 		 *			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 remain
+		 * @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;
@@ -236,12 +236,14 @@ namespace BansheeEngine
         const AABox& getBoundingBox() const;
 
 		/**
-		 * @brief	Sets the type of projection used by the camera.
+		 * @brief	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.
+		 * @brief	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;
 

BansheeUtility/Include/BsAsyncOp.h

@@ -25,7 +25,7 @@ namespace BansheeEngine
 
 	/**
 	 * @brief	Object you may use to check on the results of an asynchronous operation. 
-	 *			Contains uninitialized data until "hasCompleted" returns true. 
+	 *			Contains uninitialized data until ::hasCompleted() returns true. 
 	 * 			
 	 * @note	You are allowed (and meant to) to copy this by value.
 	 * 			

MBansheeEngine/AsyncOp.cs

@@ -6,13 +6,23 @@ using System.Text;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Object you may use to check on the results of an asynchronous operation. Contains uninitialized data until 
+    /// <see cref="IsCompleted"/> returns true.
+    /// </summary>
     public class AsyncOp : ScriptObject
     {
-        internal AsyncOp()
+        /// <summary>
+        /// Constructs a new async operation.
+        /// </summary>
+        internal AsyncOp() // Note: For internal runtime use only
         {
             Internal_CreateInstance(this);
         }
 
+        /// <summary>
+        /// Checks has the asynchronous operation completed.
+        /// </summary>
         public bool IsCompleted
         {
             get
@@ -23,11 +33,19 @@ namespace BansheeEngine
             }
         }
 
+        /// <summary>
+        /// Retrieves the value returned by the async operation. Only valid if <see cref="IsCompleted"/> returns true.
+        /// </summary>
+        /// <typeparam name="T">Type of the return value. Caller must ensure to provide the valid type.</typeparam>
+        /// <returns></returns>
         public T GetReturnValue<T>()
         {
             return (T)Internal_GetReturnValue(mCachedPtr);
         }
 
+        /// <summary>
+        /// Blocks the calling thread until asynchronous operation completes.
+        /// </summary>
         public void BlockUntilComplete()
         {
             Internal_BlockUntilComplete(mCachedPtr);

MBansheeEngine/Bounds.cs

@@ -1,14 +1,29 @@
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Bounds represented by an axis aligned box and a sphere.
+    /// </summary>
     public struct Bounds
     {
+        /// <summary>
+        /// Creates new bounds.
+        /// </summary>
+        /// <param name="box">Axis aligned box representation of the bounds.</param>
+        /// <param name="sphere">Sphere representation of the bounds.</param>
         public Bounds(AABox box, Sphere sphere)
         {
             Box = box;
             Sphere = sphere;
         }
 
+        /// <summary>
+        /// Axis aligned box representation of the bounds.
+        /// </summary>
         public AABox Box;
+
+        /// <summary>
+        /// Sphere representation of the bounds.
+        /// </summary>
         public Sphere Sphere;
     }
 }

MBansheeEngine/Builtin.cs

@@ -2,13 +2,22 @@
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Contains various builtin resources that are always available.
+    /// </summary>
     public static class Builtin
     {
+        /// <summary>
+        /// Returns a pure white texture.
+        /// </summary>
         public static SpriteTexture WhiteTexture
         {
             get { return Internal_GetWhiteTexture(); }
         }
 
+        /// <summary>
+        /// Returns the default shader to be used with renderables.
+        /// </summary>
         public static Shader DiffuseShader
         {
             get { return Internal_GetDiffuseShader(); }

MBansheeEngine/Camera.cs

@@ -6,6 +6,11 @@ using System.Text;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Camera component that 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.
+    /// </summary>
     public class Camera : Component
     {
         private NativeCamera native;
@@ -13,148 +18,326 @@ namespace BansheeEngine
         [SerializeField]
         private SerializableData serializableData = new SerializableData();
 
+        /// <summary>
+        /// Returns the non-component version of Camera that is wrapped by this component. 
+        /// </summary>
         internal NativeCamera Native
         {
             get { return native; }
         }
 
+        /// <summary>
+        /// Ratio between viewport width and height (width / height).
+        /// </summary>
         public float AspectRatio
         {
             get { return native.aspectRatio; }
             set { native.aspectRatio = value; serializableData.aspectRatio = value; }
         }
 
+        /// <summary>
+        /// Distance from the frustum origin to the near clipping plane. Anything closer than the near clipping plane will 
+        /// not be rendered. Decreasing this value decreases depth buffer precision.
+        /// </summary>
         public float NearClipPlane
         {
             get { return native.nearClipPlane; }
             set { native.nearClipPlane = value; serializableData.nearClipPlane = value; }
         }
 
+        /// <summary>
+        /// Distance from the frustum origin to the far clipping plane. Anything farther than the far clipping plane will 
+        /// not be rendered. Increasing this value decreases depth buffer precision.
+        /// </summary>
         public float FarClipPlane
         {
             get { return native.farClipPlane; }
             set { native.farClipPlane = value; serializableData.farClipPlane = value; }
         }
 
+        /// <summary>
+        /// 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.
+        /// </summary>
         public Degree FieldOfView
         {
             get { return native.fieldOfView; }
             set { native.fieldOfView = value; serializableData.fieldOfView = value; }
         }
 
+        /// <summary>
+        /// Returns the area of the render target that the camera renders to, in normalized coordinates. 
+        /// </summary>
         public Rect2 ViewportRect
         {
             get { return native.viewportRect; }
             set { native.viewportRect = value; serializableData.viewportRect = value; }
         }
 
+        /// <summary>
+        /// Projection type that controls how is 3D geometry projected onto a 2D plane.
+        /// </summary>
         public ProjectionType ProjectionType
         {
             get { return native.projectionType; }
             set { native.projectionType = value; serializableData.projectionType = value; }
         }
 
+        /// <summary>
+        /// Ortographic height that controls the size of the displayed objects. This value is only relevant when projection
+        /// type is set to orthographic. Setting this value will automatically recalculate ortographic width depending on
+        /// the aspect ratio.
+        /// </summary>
         public float OrthoHeight
         {
             get { return native.orthoHeight; }
             set { native.orthoHeight = value; serializableData.orthoHeight = value; }
         }
 
+        /// <summary>
+        /// Returns the ortographic width that controls the size of the displayed object. To change this value modify
+        /// <see cref="OrthoHeight"/> or <see cref="AspectRatio"/>.
+        /// </summary>
         public float OrthoWidth
         {
             get { return native.orthoWidth; }
         }
 
+        /// <summary>
+        /// Color that will be used for clearing the camera's viewport before rendering. Only relevant if color clear is
+        /// enabled.
+        /// </summary>
         public Color ClearColor
         {
             get { return native.clearColor; }
             set { native.clearColor = value; serializableData.clearColor = value; }
         }
 
+        /// <summary>
+        /// Value that will be used for clearing the camera's depth buffer before rendering. Only relevant if depth clear
+        /// is enabled.
+        /// </summary>
         public float ClearDepth
         {
             get { return native.clearDepth; }
             set { native.clearDepth = value; serializableData.clearDepth = value; }
         }
 
+        /// <summary>
+        /// Value that will be used for clearing the camera's stencil buffer before rendering. Only relevant if stencil
+        /// clear is enabled.
+        /// </summary>
         public UInt16 ClearStencil
         {
             get { return native.clearStencil; }
             set { native.clearStencil = value; serializableData.clearStencil = value; }
         }
 
+        /// <summary>
+        /// Flags that control which portions of the camera viewport, if any, are cleared before rendering.
+        /// </summary>
         public ClearFlags ClearFlags
         {
             get { return native.clearFlags; }
             set { native.clearFlags = value; serializableData.clearFlags = value; }
         }
 
+        /// <summary>
+        /// Determines in which orders are the cameras rendered. This only applies to cameras rendering to the same render 
+        /// target. Higher value means the camera will be processed sooner.
+        /// </summary>
         public int Priority
         {
             get { return native.priority; }
             set { native.priority = value; serializableData.priority = value; }
         }
 
+        /// <summary>
+        /// Sets layer bitfield that is used when determining which object should the camera render. Renderable objects
+        /// have their own layer flags that can be set depending on which camera you want to render them in.
+        /// </summary>
         public UInt64 Layers
         {
             get { return native.layers; }
             set { native.layers = value; serializableData.layers = value; }
         }
 
+        /// <summary>
+        /// 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.
+        /// </summary>
         public Matrix4 ProjMatrix
         {
             get { return native.projMatrix; }
         }
 
+        /// <summary>
+        /// Returns the inverse of 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.
+        /// </summary>
         public Matrix4 ProjMatrixInverse
         {
             get { return native.projMatrixInv; }
         }
 
+        /// <summary>
+        /// Returns the view matrix that controls camera position and orientation.
+        /// </summary>
         public Matrix4 ViewMatrix
         {
             get { return native.viewMatrix; }
         }
 
+        /// <summary>
+        /// Returns the inverse of the view matrix that controls camera position and orientation.
+        /// </summary>
         public Matrix4 ViewMatrixInverse
         {
             get { return native.viewMatrixInv; }
         }
 
+        /// <summary>
+        /// Returns the width of the camera's viewport, in pixels. Only valid if render target is currently set.
+        /// </summary>
         public int WidthPixels
         {
             get { return native.widthPixels; }
         }
 
+        /// <summary>
+        /// Returns the height of the camera's viewport, in pixels. Only valid if render target is currently set.
+        /// </summary>
         public int HeightPixels
         {
             get { return native.heightPixels; }
         }
 
+        /// <summary>
+        /// Returns the render target that the camera will output all rendered pixels to.
+        /// </summary>
         public RenderTarget Target
         {
             get { return native.target; }
             set { native.target = value; }
         }
 
+        /// <summary>
+        /// Converts a point in world space to screen coordinates.
+        /// </summary>
+        /// <param name="value">3D point in world space.</param>
+        /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
         public Vector2I WorldToScreen(Vector3 value) { return native.WorldToScreen(value); }
+
+        /// <summary>
+        /// Converts a point in world space to clip space coordinates.
+        /// </summary>
+        /// <param name="value">3D point in world space.</param>
+        /// <returns>2D point in normalized coordinates ([0, 1] range), relative to the camera's viewport.</returns>
         public Vector2 WorldToClip(Vector3 value) { return native.WorldToClip(value); }
+
+        /// <summary>
+        /// Converts a point in world space to view space coordinates.
+        /// </summary>
+        /// <param name="value">3D point in world space.</param>
+        /// <returns>3D point relative to the camera's coordinate system.</returns>
         public Vector3 WorldToView(Vector3 value) { return native.WorldToView(value); }
 
+        /// <summary>
+        /// Converts a point in screen space to a point in world space.
+        /// </summary>
+        /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
+        /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from 
+        ///                     camera origin to the point on the near plane.</param>
+        /// <returns>3D point in world space.</returns>
         public Vector3 ScreenToWorld(Vector2I value, float depth = 0.5f) { return native.ScreenToWorld(value, depth); }
+
+        /// <summary>
+        /// Converts a point in screen space to a point in view space.
+        /// </summary>
+        /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
+        /// <param name="depth">Depth at which place the view point at. The depth is applied to the vector going from 
+        ///                     camera origin to the point on the near plane.</param>
+        /// <returns>3D point in view space.</returns>
         public Vector3 ScreenToView(Vector2I value, float depth = 0.5f) { return native.ScreenToView(value, depth); }
+
+        /// <summary>
+        /// Converts a point in screen space to a point in normalized clip space.
+        /// </summary>
+        /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
+        /// <returns>2D point in normalized cliped space ([0, 1] range), relative to the camera's viewport.</returns>
         public Vector2 ScreenToClip(Vector2I value) { return native.ScreenToClip(value); }
 
+        /// <summary>
+        /// Converts a point relative to camera's coordinate system (view space) into a point in world space.
+        /// </summary>
+        /// <param name="value">3D point in view space.</param>
+        /// <returns>3D point in world space.</returns>
         public Vector3 ViewToWorld(Vector3 value) { return native.ViewToWorld(value); }
+
+        /// <summary>
+        /// Converts a point relative to camera's coordinate system (view space) to screen coordinates.
+        /// </summary>
+        /// <param name="value">3D point in view space.</param>
+        /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
         public Vector2I ViewToScreen(Vector3 value) { return native.ViewToScreen(value); }
+
+        /// <summary>
+        /// Converts a point relative to camera's coordinate system (view space) to normalized clip space.
+        /// </summary>
+        /// <param name="value">3D point in view space.</param>
+        /// <returns>2D point in normalized cliped space ([0, 1] range), relative to the camera's viewport.</returns>
         public Vector2 ViewToClip(Vector3 value) { return native.ViewToClip(value); }
 
+        /// <summary>
+        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) into a point in 
+        /// world space.
+        /// </summary>
+        /// <param name="value">2D point in normalized clip space.</param>
+        /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from
+        ///                     camera origin to the point on the near plane.</param>
+        /// <returns>3D point in world space.</returns>
         public Vector3 ClipToWorld(Vector2 value, float depth = 0.5f) { return native.ClipToWorld(value, depth); }
+
+        /// <summary>
+        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) into a point in 
+        /// view space.
+        /// </summary>
+        /// <param name="value">2D point in normalized clip space.</param>
+        /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from
+        ///                     camera origin to the point on the near plane.</param>
+        /// <returns>3D point in view space.</returns>
         public Vector3 ClipToView(Vector2 value, float depth = 0.5f) { return native.ClipToView(value, depth); }
+
+        /// <summary>
+        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) to screen space.
+        /// </summary>
+        /// <param name="value">2D point in normalized clip space.</param>
+        /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
         public Vector2I ClipToScreen(Vector2 value) { return native.ClipToScreen(value); }
 
+        /// <summary>
+        /// Converts a point in screen space in a ray in world space.
+        /// </summary>
+        /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
+        /// <returns>A ray in world space with it's origin the selected point at the near frustum plane, pointing in the 
+        ///          direction going from camera's origin towards a point on the near frustum plane.</returns>
         public Ray ScreenToWorldRay(Vector2I value) { return native.ScreenToWorldRay(value); }
+
+        /// <summary>
+        /// Projects a point in view space to a point in clip space. Similar to <see cref="ViewToClip"/> but preserves
+        /// the depth component.
+        /// </summary>
+        /// <param name="value">3D point in view space.</param>
+        /// <returns>3D point in normalized cliped space ([0, 1] range), relative to the camera's viewport. Z value
+        ///          range depends on active render API.</returns>
         public Vector3 ProjectPoint(Vector3 value) { return native.ProjectPoint(value); }
+
+        /// <summary>
+        /// Un-rpojects a point in clip space to a point in view space.
+        /// </summary>
+        /// <param name="value">3D point in normalized cliped space ([0, 1] range), relative to the camera's viewport. 
+        ///                     Z value range depends on active render API.</param>
+        /// <returns>3D point in view space.</returns>
         public Vector3 UnprojectPoint(Vector3 value) { return native.UnprojectPoint(value); }
 
         private void OnInitialize()
@@ -206,6 +389,9 @@ namespace BansheeEngine
             native.OnDestroy();
         }
 
+        /// <summary>
+        /// Holds all data the camera component needs to persist through serialization.
+        /// </summary>
         [SerializeObject]
         private struct SerializableData
         {

MBansheeEngine/Color.cs

@@ -3,8 +3,11 @@ using System.Runtime.InteropServices;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Contains a three-component color with an alpha component.
+    /// </summary>
     [StructLayout(LayoutKind.Sequential), SerializeObject]
-    public struct Color
+    public struct Color // Note: Must match C++ class Color
     {
         public float r;
         public float g;
@@ -23,6 +26,11 @@ namespace BansheeEngine
 
         public static Color BansheeOrange { get { return new Color(1.0f, (168.0f/255.0f), 0.0f, 1.0f); } }
         
+        /// <summary>
+        /// Accesses color components by an index.
+        /// </summary>
+        /// <param name="index">Index ranging [0, 3]</param>
+        /// <returns>Value of the component at the specified index.</returns>
         public float this[int index]
         {
             get
@@ -63,6 +71,13 @@ namespace BansheeEngine
             }
         }
 
+        /// <summary>
+        /// Creates a new color value.
+        /// </summary>
+        /// <param name="r">Red component, in range [0, 1].</param>
+        /// <param name="g">Green component, in range [0, 1].</param>
+        /// <param name="b">Blue component, in range [0, 1].</param>
+        /// <param name="a">Alpha component, in range [0, 1].</param>
         public Color(float r, float g, float b, float a)
         {
             this.r = r;
@@ -71,6 +86,12 @@ namespace BansheeEngine
             this.a = a;
         }
 
+        /// <summary>
+        /// Creates a new color value. Alpha is assumed to be 1 (non-transparent).
+        /// </summary>
+        /// <param name="r">Red component, in range [0, 1].</param>
+        /// <param name="g">Green component, in range [0, 1].</param>
+        /// <param name="b">Blue component, in range [0, 1].</param>
         public Color(float r, float g, float b)
         {
             this.r = r;
@@ -119,6 +140,11 @@ namespace BansheeEngine
             return !(lhs == rhs);
         }
 
+        /// <summary>
+        /// Converts the provided RGB color into HSV color space.
+        /// </summary>
+        /// <param name="input">Color in RGB color space.</param>
+        /// <returns>Color in HSV color space.</returns>
         public static Color RGB2HSV(Color input)
         {
             Color output = input;
@@ -159,6 +185,11 @@ namespace BansheeEngine
             return output;
         }
 
+        /// <summary>
+        /// Converts the provided HSV color into RGB color space.
+        /// </summary>
+        /// <param name="input">Color in HSV color space.</param>
+        /// <returns>Color in RGB color space.</returns>
         public static Color HSV2RGB(Color input)
         {
             Color output = input;
@@ -221,11 +252,13 @@ namespace BansheeEngine
             return output;
         }
 
+        /// <inheritdoc/>
         public override int GetHashCode()
         {
             return r.GetHashCode() ^ g.GetHashCode() << 2 ^ b.GetHashCode() >> 2 ^ a.GetHashCode() >> 1;
         }
 
+        /// <inheritdoc/>
         public override bool Equals(object other)
         {
             if (!(other is Color))

MBansheeEngine/Component.cs

@@ -3,12 +3,19 @@ using System.Runtime.CompilerServices;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Base class for all components. Components represent primary logic elements in the scene. They are attached to 
+    /// scene objects.
+    /// </summary>
     public class Component : GameObject
     {
         // Internal use only
         protected Component()
         { }
 
+        /// <summary>
+        /// Returns the scene object this component is attached to.
+        /// </summary>
         public SceneObject SceneObject
         {
             get { return Internal_GetSceneObject(mCachedPtr); }

MBansheeEngine/ContextMenu.cs

@@ -4,44 +4,92 @@ using System.Runtime.CompilerServices;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Contains data used for initializing a context menu used on GUI elements. When specifying menu items you must provide
+    /// a path. Path must be formated in a certain way. All path elements must be separated by /, e.g. "View/Toolbars/Find". 
+    /// "View" would be the top level path element, "Toolbars" a child in its menu that opens up its own submenu, and "Find"
+    /// a child in the "Toolbars" sub-menu with an optional callback.
+    /// </summary>
     public class ContextMenu : ScriptObject
     {
         private List<Action> callbacks = new List<Action>(); 
 
+        /// <summary>
+        /// Creates a new empty context menu data.
+        /// </summary>
         public ContextMenu()
         {
             Internal_CreateInstance(this);
         }
 
+        /// <summary>
+        /// Adds a new item to the menu.
+        /// </summary>
+        /// <param name="path">Path that determines where to add the element. See class information on how to specify paths.
+        ///                    All sub-elements of a path will be added automatically.</param>
+        /// <param name="callback">Callback to trigger when the path element is selected.</param>
         public void AddItem(string path, Action callback)
         {
             Internal_AddItem(mCachedPtr, path, callbacks.Count, ShortcutKey.None);
             callbacks.Add(callback);
         }
 
+        /// <summary>
+        /// Adds a new item to the menu.
+        /// </summary>
+        /// <param name="path">Path that determines where to add the element. See class information on how to specify paths.
+        ///                    All sub-elements of a path will be added automatically.</param>
+        /// <param name="callback">Callback to trigger when the path element is selected.</param>
+        /// <param name="shortcut">Keyboard shortcut to display next to the item name.</param>
         public void AddItem(string path, Action callback, ShortcutKey shortcut)
         {
             Internal_AddItem(mCachedPtr, path, callbacks.Count, shortcut);
             callbacks.Add(callback);
         }
 
+        /// <summary>
+        /// Adds a new item to the menu.
+        /// </summary>
+        /// <param name="path">Path that determines where to add the element. See class information on how to specify paths.
+        ///                    All sub-elements of a path will be added automatically.</param>
+        /// <param name="callback">Callback to trigger when the path element is selected.</param>
+        /// <param name="name">Localized name for the menu item.</param>
         public void AddItem(string path, Action callback, LocString name)
         {
             Internal_AddItem(mCachedPtr, path, callbacks.Count, ShortcutKey.None);
             callbacks.Add(callback);
         }
 
+        /// <summary>
+        /// Adds a new item to the menu.
+        /// </summary>
+        /// <param name="path">Path that determines where to add the element. See class information on how to specify paths.
+        ///                    All sub-elements of a path will be added automatically.</param>
+        /// <param name="callback">Callback to trigger when the path element is selected.</param>
+        /// <param name="shortcut">Keyboard shortcut to display next to the item name.</param>
+        /// <param name="name">Localized name for the menu item.</param>
         public void AddItem(string path, Action callback, ShortcutKey shortcut, LocString name)
         {
             Internal_AddItem(mCachedPtr, path, callbacks.Count, shortcut);
             callbacks.Add(callback);
         }
 
+        /// <summary>
+        /// Adds a new separator to the menu.
+        /// </summary>
+        /// <param name="path">Path that determines where to add the element. See class information on how to specify paths.
+        ///                    All sub-elements of a path will be added automatically.</param>
         public void AddSeparator(string path)
         {
             Internal_AddSeparator(mCachedPtr, path);
         }
 
+        /// <summary>
+        /// Sets a localized name of a specific menu element. If no localized name is set element labels will be displayed
+        /// as their names.
+        /// </summary>
+        /// <param name="label">Label of the element.</param>
+        /// <param name="name">Name to display when the menu is shown.</param>
         public void SetLocalizedName(string label, LocString name)
         {
             IntPtr namePtr = IntPtr.Zero;
@@ -51,6 +99,10 @@ namespace BansheeEngine
             Internal_SetLocalizedName(mCachedPtr, label, namePtr);
         }
 
+        /// <summary>
+        /// Triggered by the runtime when an element is selected the context menu.
+        /// </summary>
+        /// <param name="callbackIdx">Unique index of the element that was selected.</param>
         private void InternalDoOnEntryTriggered(int callbackIdx)
         {
             if (callbackIdx < 0 || callbackIdx >= callbacks.Count)

MBansheeEngine/Cursor.cs

@@ -6,8 +6,14 @@ using System.Text;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Allows manipulation of the platform cursor.
+    /// </summary>
     public static class Cursor
     {
+        /// <summary>
+        /// Position of the cursor in screen coordinates.
+        /// </summary>
         public static Vector2I ScreenPosition
         {
             get
@@ -23,51 +29,93 @@ namespace BansheeEngine
             }
         }
 
+        /// <summary>
+        /// Hides the cursor.
+        /// </summary>
         public static void Hide()
         {
             Internal_Hide();
         }
 
+        /// <summary>
+        /// Shows the cursor.
+        /// </summary>
         public static void Show()
         {
             Internal_Show();
         }
 
+        /// <summary>
+        /// Clips the cursor to the specified area. Enabled until <see cref="ClipDisable"/> is called.
+        /// </summary>
+        /// <param name="area">Area in screen space to clip the cursor to.</param>
         public static void ClipToRect(Rect2I area)
         {
             Internal_ClipToRect(area);
         }
 
+        /// <summary>
+        /// Disables cursor clipping previously enabled with <see cref="ClipToRect"/>.
+        /// </summary>
         public static void ClipDisable()
         {
             Internal_ClipDisable();
         }
 
+        /// <summary>
+        /// Changes the active cursor icon.
+        /// </summary>
+        /// <param name="name">Name of the cursor icon, previously registered with 
+        ///                    <see cref="SetCursorIcon(string,PixelData,Vector2I)"/></param>
         public static void SetCursor(string name)
         {
             Internal_SetCursorStr(name);
         }
 
+        /// <summary>
+        /// Changes the active cursor icon.
+        /// </summary>
+        /// <param name="type">One of the built-in cursor types.</param>
         public static void SetCursor(CursorType type)
         {
             Internal_SetCursor(type);
         }
 
+        /// <summary>
+        /// Updates the look of a specific cursor icon.
+        /// </summary>
+        /// <param name="name">Name of the cursor.</param>
+        /// <param name="iconData">Pixel data specifying the new look.</param>
+        /// <param name="hotspot">Offset into the icon image that determines where the cursor point is.</param>
         public static void SetCursorIcon(string name, PixelData iconData, Vector2I hotspot)
         {
             Internal_SetCursorIconStr(name, iconData, hotspot);
         }
 
+        /// <summary>
+        /// Updates the look of a specific cursor icon.
+        /// </summary>
+        /// <param name="type">One of the built-in cursor types.</param>
+        /// <param name="iconData">Pixel data specifying the new look.</param>
+        /// <param name="hotspot">Offset into the icon image that determines where the cursor point is.</param>
         public static void SetCursorIcon(CursorType type, PixelData iconData, Vector2I hotspot)
         {
             Internal_SetCursorIcon(type, iconData, hotspot);
         }
 
+        /// <summary>
+        /// Removes a cursor icon.
+        /// </summary>
+        /// <param name="name">Name of the cursor.</param>
         public static void ClearCursorIcon(string name)
         {
             Internal_ClearCursorIconStr(name);
         }
 
+        /// <summary>
+        /// Removes a cursor icon.
+        /// </summary>
+        /// <param name="type">One of the built-in cursor types.</param>
         public static void ClearCursorIcon(CursorType type)
         {
             Internal_ClearCursorIcon(type);
@@ -110,8 +158,10 @@ namespace BansheeEngine
         private static extern void Internal_ClearCursorIcon(CursorType cursor);
     }
 
-    // Note: Do not modify indexes, they need to match C++ enum CursorType
-	public enum CursorType
+    /// <summary>
+    /// Built-in cursor types.
+    /// </summary>
+    public enum CursorType //Note: Must match C++ enum CursorType
 	{
 		Arrow,
 		ArrowDrag,

MBansheeEngine/Debug.cs

@@ -7,8 +7,15 @@ using System.Text;
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Utility class providing various debug functionality.
+    /// </summary>
     public sealed class Debug
     {
+        /// <summary>
+        /// Logs a new informative message to the global debug log.
+        /// </summary>
+        /// <param name="message">Message to log.</param>
         public static void Log(object message)
         {
             StringBuilder sb = new StringBuilder();
@@ -18,6 +25,10 @@ namespace BansheeEngine
             Internal_Log(sb.ToString());
         }
 
+        /// <summary>
+        /// Logs a new warning message to the global debug log.
+        /// </summary>
+        /// <param name="message">Message to log.</param>
         public static void LogWarning(object message)
         {
             StringBuilder sb = new StringBuilder();
@@ -27,6 +38,10 @@ namespace BansheeEngine
             Internal_LogWarning(sb.ToString());
         }
 
+        /// <summary>
+        /// Logs a new error message to the global debug log.
+        /// </summary>
+        /// <param name="message">Message to log.</param>
         public static void LogError(object message)
         {
             StringBuilder sb = new StringBuilder();
@@ -36,6 +51,10 @@ namespace BansheeEngine
             Internal_LogError(sb.ToString());
         }
 
+        /// <summary>
+        /// Returns the stack trace of the current point in code.
+        /// </summary>
+        /// <returns>String containing the stack trace.</returns>
         public static string GetStackTrace()
         {
             StackTrace stackTrace = new StackTrace(1, true);

MBansheeEngine/DirectoryEx.cs

@@ -2,8 +2,16 @@
 
 namespace BansheeEngine
 {
+    /// <summary>
+    /// Contains various methods that provide handling for directories not provided by System.Directory type.
+    /// </summary>
     public static class DirectoryEx
     {
+        /// <summary>
+        /// Moves a directory from one path to another, while creating any parent directories if they don't already exist.
+        /// </summary>
+        /// <param name="source">Path to the directory to move.</param>
+        /// <param name="destination">New location and/or name of the directory.</param>
         public static void Move(string source, string destination)
         {
             string destParent = PathEx.GetParent(destination);
@@ -16,6 +24,12 @@ namespace BansheeEngine
             Directory.Move(source, destination);
         }
 
+        /// <summary>
+        /// Recursively copies a directory from one path to another, while creating any parent directories if they don't 
+        /// already exist.
+        /// </summary>
+        /// <param name="source">Path to the directory to copy.</param>
+        /// <param name="destination">Path determining where the directory copy will be placed.</param>
         public static void Copy(string source, string destination)
         {
             DirectoryInfo dir = new DirectoryInfo(source);

MBansheeEngine/GUI/GUIButton.cs

@@ -36,15 +36,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIButton(GUIContent content, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, style, options);
@@ -53,12 +50,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUIButton(GUIContent content, string style)
         {
             Internal_CreateInstance(this, content, style, new GUIOption[0]);
@@ -67,11 +62,9 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIButton(GUIContent content, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, "", options);

MBansheeEngine/GUI/GUIContent.cs

@@ -79,11 +79,9 @@ namespace BansheeEngine
         /// <summary>
         /// Constructs content with a string and an image.
         /// </summary>
-        /// <param name="text">Textual portion of the content to be displayed as label in GUI elements.
-        /// </param>
+        /// <param name="text">Textual portion of the content to be displayed as label in GUI elements.</param>
         /// <param name="image">Image to be displayed on top of the GUI element. Image will be placed to the right or to the 
-        /// left of the text depending on active GUI style.
-        /// </param>
+        ///                     left of the text depending on active GUI style.</param>
         public GUIContent(LocString text, SpriteTexture image)
         {
             this.text = text;
@@ -93,13 +91,10 @@ namespace BansheeEngine
         /// <summary>
         /// Constructs content with a string, an image and a tooltip.
         /// </summary>
-        /// <param name="text">Textual portion of the content to be displayed as label in GUI elements.
-        /// </param>
+        /// <param name="text">Textual portion of the content to be displayed as label in GUI elements.</param>
         /// <param name="image">Image to be displayed on top of the GUI element. Image will be placed to the right or to the 
-        /// left of the text depending on active GUI style.
-        /// </param>
-        /// <param name="tooltip">Tooltip to be displayed when user hovers over a GUI element.
-        /// </param>
+        ///                     left of the text depending on active GUI style.</param>
+        /// <param name="tooltip">Tooltip to be displayed when user hovers over a GUI element.</param>
         public GUIContent(LocString text, SpriteTexture image, LocString tooltip)
         {
             this.text = text;

MBansheeEngine/GUI/GUIElement.cs

@@ -84,14 +84,12 @@ namespace BansheeEngine
         }
 
         /// <summary>
-        /// Sets a flexible element width. Element will be resized according to its contents and parent layout but will always
-        /// stay within the provided range.
+        /// Sets a flexible element width. Element will be resized according to its contents and parent layout but will 
+        /// always stay within the provided range.
         /// </summary>
-        /// <param name="minWidth">Minimum width in pixels. Element will never be smaller than this width.
-        /// </param>
+        /// <param name="minWidth">Minimum width in pixels. Element will never be smaller than this width.</param>
         /// <param name="maxWidth">Maximum width in pixels. Element will never be larger than this width. Specify zero for 
-        /// unlimited width.
-        /// </param>
+        ///                        unlimited width.</param>
         public void SetFlexibleWidth(int minWidth, int maxWidth)
         {
             Internal_SetFlexibleWidth(mCachedPtr, minWidth, maxWidth);
@@ -110,11 +108,9 @@ namespace BansheeEngine
         /// Sets a flexible element height. Element will be resized according to its contents and parent layout but will 
         /// always stay within the provided range.
         /// </summary>
-        /// <param name="minHeight">Minimum height in pixels. Element will never be smaller than this height.
-        /// </param>
-        /// <param name="maxHeight">Maximum height in pixels. Element will never be larger than this height. Specify zero for 
-        /// unlimited height.
-        /// </param>
+        /// <param name="minHeight">Minimum height in pixels. Element will never be smaller than this height.</param>
+        /// <param name="maxHeight">Maximum height in pixels. Element will never be larger than this height. Specify zero 
+        ///                         for unlimited height.</param>
         public void SetFlexibleHeight(int minHeight, int maxHeight)
         {
             Internal_SetFlexibleHeight(mCachedPtr, minHeight, maxHeight);

MBansheeEngine/GUI/GUIElementStyle.cs

@@ -287,11 +287,9 @@ namespace BansheeEngine
         /// <summary>
         /// Registers a new sub-style that is used by complex GUI elements that contain one or multiple sub-elements.
         /// </summary>
-        /// <param name="guiType">Name of the sub-element this style is to be used for.  This depends on GUI element the style
-        /// is applied to.
-        /// </param>
-        /// <param name="styleName">Name of the style in GUI skin to use for the sub-element.
-        /// </param>
+        /// <param name="guiType">Name of the sub-element this style is to be used for.  This depends on GUI element the 
+        ///                       style is applied to.</param>
+        /// <param name="styleName">Name of the style in GUI skin to use for the sub-element.</param>
         public void AddSubStyle(string guiType, string styleName)
         {
             if (guiType == null || styleName == null)

MBansheeEngine/GUI/GUILabel.cs

@@ -11,15 +11,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new label element.
         /// </summary>
-        /// <param name="content">Content to display on the label.
-        /// </param>
+        /// <param name="content">Content to display on the label.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUILabel(GUIContent content, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, style, options);
@@ -28,12 +25,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new label element.
         /// </summary>
-        /// <param name="content">Content to display on the label.
-        /// </param>
+        /// <param name="content">Content to display on the label.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUILabel(GUIContent content, string style = "")
         {
             Internal_CreateInstance(this, content, style, new GUIOption[0]);
@@ -42,11 +37,9 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new label element.
         /// </summary>
-        /// <param name="content">Content to display on the label.
-        /// </param>
+        /// <param name="content">Content to display on the label.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUILabel(GUIContent content, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, "", options);

MBansheeEngine/GUI/GUILayout.cs

@@ -94,17 +94,13 @@ namespace BansheeEngine
         /// Adds a new GUI panel as a child of this layout. Panel is inserted after all existing elements.
         /// </summary>
         /// <param name="depth">Depth at which to position the panel. Panels with lower depth will be displayed in front of 
-        /// panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. The depth value will
-        /// be clamped if outside of the depth range of the parent GUI panel.
-        /// </param>
+        ///                     panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. 
+        ///                     The depth value will be clamped if outside of the depth range of the parent GUI panel.</param>
         /// <param name="depthRangeMin">Smallest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset lower than this value it will be clamped.
-        /// </param>
+        ///                             offset lower than this value it will be clamped.</param>
         /// <param name="depthRangeMax">Largest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset higher than this value it will be clamped.
-        /// </param>
-        /// <param name="options">Options that allow you to control how is the panel positioned and sized. 
-        /// </param>
+        ///                             offset higher than this value it will be clamped.</param>
+        /// <param name="options">Options that allow you to control how is the panel positioned and sized.</param>
         /// <returns>Newly created GUI panel.</returns>
         public GUIPanel AddPanel(Int16 depth = 0, ushort depthRangeMin = ushort.MaxValue, 
             ushort depthRangeMax = ushort.MaxValue, params GUIOption[] options)
@@ -131,8 +127,7 @@ namespace BansheeEngine
         /// width or height (depending on layout type) in the layout. Space is inserted after all existing elements.
         /// </summary>
         /// <param name="size">Size of the space in pixels. This will represent either width or height depending whether the 
-        /// layout is vertical or horizontal.
-        /// </param>
+        ///                    layout is vertical or horizontal.</param>
         /// <returns>Newly created fixed space.</returns>
         public GUIFixedSpace AddSpace(int size)
         {
@@ -145,7 +140,7 @@ namespace BansheeEngine
         /// Adds a new horizontal layout as a child of this layout. Layout is inserted
         /// before the element at the specified index.
         /// </summary>
-        /// <param name="idx">Index to insert the layout at. This must be in range [0, GetNumChildren()) </param>
+        /// <param name="idx">Index to insert the layout at. This must be in range [0, GetNumChildren()).</param>
         /// <param name="options">Options that allow you to control how is the layout positioned and sized.</param>
         /// <returns>Newly created horizontal layout.</returns>
         public GUILayoutX InsertLayoutX(int idx, params GUIOption[] options)
@@ -186,17 +181,13 @@ namespace BansheeEngine
         /// Adds a new GUI panel as a child of this layout. Panel is inserted before the element at the specified index.
         /// </summary>
         /// <param name="depth">Depth at which to position the panel. Panels with lower depth will be displayed in front of 
-        /// panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. The depth value will
-        /// be clamped if outside of the depth range of the parent GUI panel.
-        /// </param>
+        ///                     panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. 
+        ///                     The depth value will be clamped if outside of the depth range of the parent GUI panel.</param>
         /// <param name="depthRangeMin">Smallest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset lower than this value it will be clamped.
-        /// </param>
+        ///                             offset lower than this value it will be clamped.</param>
         /// <param name="depthRangeMax">Largest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset higher than this value it will be clamped.
-        /// </param>
-        /// <param name="options">Options that allow you to control how is the panel positioned and sized. 
-        /// </param>
+        ///                             offset higher than this value it will be clamped.</param>
+        /// <param name="options">Options that allow you to control how is the panel positioned and sized.</param>
         /// <returns>Newly created GUI panel.</returns>
         public GUIPanel InsertPanel(int idx, Int16 depth = 0, ushort depthRangeMin = ushort.MaxValue, 
             ushort depthRangeMax = ushort.MaxValue, params GUIOption[] options)

MBansheeEngine/GUI/GUILayoutUtility.cs

@@ -28,11 +28,10 @@ namespace BansheeEngine
         /// Calculates the bounds of a GUI element. This is similar to <see cref="GUIElement.Bounds"/> but allows you to
         /// returns bounds relative to a specific parent GUI panel.
         /// </summary>
-        /// <param name="element">Elements to calculate the bounds for.
-        /// </param>
+        /// <param name="element">Elements to calculate the bounds for.</param>
         /// <param name="relativeTo">GUI panel the bounds will be relative to. If this is null or the provided panel is not
-        /// a parent of the provided GUI element, the returned bounds will be relative to the first GUI panel parent instead.
-        /// </param>
+        ///                          a parent of the provided GUI element, the returned bounds will be relative to the 
+        ///                          first GUI panel parent instead.</param>
         /// <returns>Bounds of a GUI element relative to the provided GUI panel.</returns>
         public static Rect2I CalculateBounds(GUIElement element, GUIPanel relativeTo = null)
         {

MBansheeEngine/GUI/GUIListBox.cs

@@ -19,16 +19,13 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new list box with the specified elements.
         /// </summary>
-        /// <param name="elements">Array of elements to display in the list box. Elements will be displayed in the same order
-        /// as in the array.
-        /// </param>
+        /// <param name="elements">Array of elements to display in the list box. Elements will be displayed in the same 
+        ///                        order as in the array.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIListBox(LocString[] elements, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, elements, style, options);
@@ -37,12 +34,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new list box with the specified elements.
         /// </summary>
-        /// <param name="elements">Array of elements to display in the list box. Elements will be displayed in the same order
-        /// as in the array.
-        /// </param>
+        /// <param name="elements">Array of elements to display in the list box. Elements will be displayed in the same 
+        ///                        order as in the array.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIListBox(LocString[] elements, params GUIOption[] options)
         {
             Internal_CreateInstance(this, elements, "", options);

MBansheeEngine/GUI/GUIOption.cs

@@ -77,11 +77,9 @@ namespace BansheeEngine
         /// constraints. Element will be resized according to its contents and parent layout but will always stay within the 
         /// provided range.
         /// </summary>
-        /// <param name="minWidth">Minimum width in pixels. Element will never be smaller than this width.
-        /// </param>
+        /// <param name="minWidth">Minimum width in pixels. Element will never be smaller than this width.</param>
         /// <param name="maxWidth">Maximum width in pixels. Element will never be larger than this width. Specify zero for 
-        /// unlimited width.
-        /// </param>
+        ///                        unlimited width.</param>
         /// <returns>New option object that can be used for initializing a GUI element.</returns>
         public static GUIOption FlexibleWidth(int minWidth = 0, int maxWidth = 0)
         {
@@ -98,11 +96,9 @@ namespace BansheeEngine
         /// constraints. Element will be resized according to its contents and parent layout but will always stay within the 
         /// provided range.
         /// </summary>
-        /// <param name="minHeight">Minimum height in pixels. Element will never be smaller than this height.
-        /// </param>
-        /// <param name="maxHeight">Maximum height in pixels. Element will never be larger than this height. Specify zero for 
-        /// unlimited height.
-        /// </param>
+        /// <param name="minHeight">Minimum height in pixels. Element will never be smaller than this height.</param>
+        /// <param name="maxHeight">Maximum height in pixels. Element will never be larger than this height. Specify zero for
+        ///                          unlimited height.</param>
         /// <returns>New option object that can be used for initializing a GUI element.</returns>
         public static GUIOption FlexibleHeight(int minHeight = 0, int maxHeight = 0)
         {

MBansheeEngine/GUI/GUIPanel.cs

@@ -15,17 +15,13 @@ namespace BansheeEngine
         /// Constructs a new GUI panel object.
         /// </summary>
         /// <param name="depth">Depth at which to position the panel. Panels with lower depth will be displayed in front of 
-        /// panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. The depth value will
-        /// be clamped if outside of the depth range of the parent GUI panel.
-        /// </param>
+        ///                     panels with higher depth. Provided depth is relative to the depth of the parent GUI panel. 
+        ///                     The depth value will be clamped if outside of the depth range of the parent GUI panel.</param>
         /// <param name="depthRangeMin">Smallest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset lower than this value it will be clamped.
-        /// </param>
+        ///                             offset lower than this value it will be clamped.</param>
         /// <param name="depthRangeMax">Largest depth offset allowed by any child GUI panels. If a child panel has a depth 
-        /// offset higher than this value it will be clamped.
-        /// </param>
-        /// <param name="options">Options that allow you to control how is the panel positioned and sized. 
-        /// </param>
+        ///                             offset higher than this value it will be clamped.</param>
+        /// <param name="options">Options that allow you to control how is the panel positioned and sized.</param>
         public GUIPanel(Int16 depth = 0, ushort depthRangeMin = ushort.MaxValue, ushort depthRangeMax = ushort.MaxValue, 
             params GUIOption[] options)
         {
@@ -35,8 +31,7 @@ namespace BansheeEngine
         /// <summary>
         /// Constructs a new GUI panel object.
         /// </summary>
-        /// <param name="options">Options that allow you to control how is the panel positioned and sized. 
-        /// </param>
+        /// <param name="options">Options that allow you to control how is the panel positioned and sized.</param>
         public GUIPanel(params GUIOption[] options)
         {
             Internal_CreateInstancePanel(this, 0, ushort.MaxValue, ushort.MaxValue, options);

MBansheeEngine/GUI/GUIProgressBar.cs

@@ -22,12 +22,10 @@ namespace BansheeEngine
         /// Creates a new progress bar element.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIProgressBar(string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, style, options);
@@ -37,9 +35,8 @@ namespace BansheeEngine
         /// Creates a new progress bar element.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUIProgressBar(string style = "")
         {
             Internal_CreateInstance(this, style, new GUIOption[0]);

MBansheeEngine/GUI/GUIRenderTexture.cs

@@ -37,12 +37,10 @@ namespace BansheeEngine
         /// </summary>
         /// <param name="texture">Render texture to display in the element.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIRenderTexture(RenderTexture2D texture, string style, params GUIOption[] options)
         {
             IntPtr texturePtr = IntPtr.Zero;
@@ -57,8 +55,7 @@ namespace BansheeEngine
         /// </summary>
         /// <param name="texture">Render texture to display in the element.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIRenderTexture(RenderTexture2D texture, params GUIOption[] options)
         {
             IntPtr texturePtr = IntPtr.Zero;

MBansheeEngine/GUI/GUIScrollArea.cs

@@ -69,20 +69,15 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new scroll area.
         /// </summary>
-        /// <param name="vertBarType">Type of the vertical scroll bar.
-        /// </param>
-        /// <param name="horzBarType">Type of the horizontal scroll bar.
-        /// </param>
-        /// <param name="scrollBarStyle">Optional style that controls the look of the scroll bars. Style will be retrieved from the 
-        /// active GUISkin. If not specified default element style is used.
-        /// </param>        
+        /// <param name="vertBarType">Type of the vertical scroll bar.</param>
+        /// <param name="horzBarType">Type of the horizontal scroll bar.</param>
+        /// <param name="scrollBarStyle">Optional style that controls the look of the scroll bars. Style will be retrieved 
+        ///                              from the active GUISkin. If not specified default element style is used.</param>        
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(ScrollBarType vertBarType, ScrollBarType horzBarType, string scrollBarStyle,
             string style, params GUIOption[] options)
         {
@@ -93,17 +88,13 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new scroll area.
         /// </summary>
-        /// <param name="vertBarType">Type of the vertical scroll bar.
-        /// </param>
-        /// <param name="horzBarType">Type of the horizontal scroll bar.
-        /// </param>
+        /// <param name="vertBarType">Type of the vertical scroll bar.</param>
+        /// <param name="horzBarType">Type of the horizontal scroll bar.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(ScrollBarType vertBarType, ScrollBarType horzBarType, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, vertBarType, horzBarType, "", style, options);
@@ -113,13 +104,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new scroll area.
         /// </summary>
-        /// <param name="vertBarType">Type of the vertical scroll bar.
-        /// </param>
-        /// <param name="horzBarType">Type of the horizontal scroll bar.
-        /// </param>
+        /// <param name="vertBarType">Type of the vertical scroll bar.</param>
+        /// <param name="horzBarType">Type of the horizontal scroll bar.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(ScrollBarType vertBarType, ScrollBarType horzBarType, params GUIOption[] options)
         {
             Internal_CreateInstance(this, vertBarType, horzBarType, "", "", options);
@@ -130,12 +118,10 @@ namespace BansheeEngine
         /// Creates a new scroll area.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, ScrollBarType.ShowIfDoesntFit, ScrollBarType.ShowIfDoesntFit, "", style, options);
@@ -146,8 +132,7 @@ namespace BansheeEngine
         /// Creates a new scroll area.
         /// </summary>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(params GUIOption[] options)
         {
             Internal_CreateInstance(this, ScrollBarType.ShowIfDoesntFit, ScrollBarType.ShowIfDoesntFit, "", "", options);
@@ -157,12 +142,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new scroll area.
         /// </summary>
-        /// <param name="scrollBarStyle">Optional style that controls the look of the scroll bars. Style will be retrieved from the 
-        /// active GUISkin. If not specified default element style is used.
-        /// </param>        
+        /// <param name="scrollBarStyle">Optional style that controls the look of the scroll bars. Style will be retrieved 
+        ///                              from the active GUISkin. If not specified default element style is used.</param>        
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIScrollArea(string scrollBarStyle, string scrollAreaStyle, params GUIOption[] options)
         {
             Internal_CreateInstance(this, ScrollBarType.ShowIfDoesntFit, ScrollBarType.ShowIfDoesntFit, scrollBarStyle, scrollAreaStyle, options);

MBansheeEngine/GUI/GUISlider.cs

@@ -29,12 +29,10 @@ namespace BansheeEngine
         /// Creates a new horizontal slider.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUISliderH(string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, style, options);
@@ -44,9 +42,8 @@ namespace BansheeEngine
         /// Creates a new vertical slider.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUISliderH(string style = "")
         {
             Internal_CreateInstance(this, style, new GUIOption[0]);
@@ -110,12 +107,10 @@ namespace BansheeEngine
         /// Creates a new vertical slider.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUISliderV(string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, style, options);
@@ -125,9 +120,8 @@ namespace BansheeEngine
         /// Creates a new vertical slider.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUISliderV(string style = "")
         {
             Internal_CreateInstance(this, style, new GUIOption[0]);

MBansheeEngine/GUI/GUISpace.cs

@@ -12,8 +12,7 @@ namespace BansheeEngine
         /// Creates a new fixed space. 
         /// </summary>
         /// <param name="size">Size of the space in pixels. This will represent either width or height depending whether the 
-        /// layout is vertical or horizontal.
-        /// </param>
+        ///                    layout is vertical or horizontal.</param>
         public GUIFixedSpace(int size)
         {
             Internal_CreateInstance(this, size);

MBansheeEngine/GUI/GUITextBox.cs

@@ -19,15 +19,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new text box element.
         /// </summary>
-        /// <param name="multiline">Determines should the input box allow text that spans multiple lines.
-        /// </param>
+        /// <param name="multiline">Determines should the input box allow text that spans multiple lines.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITextBox(bool multiline, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, multiline, style, options);
@@ -36,11 +33,9 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new text box element.
         /// </summary>
-        /// <param name="multiline">Determines should the input box allow text that spans multiple lines.
-        /// </param>
+        /// <param name="multiline">Determines should the input box allow text that spans multiple lines.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITextBox(bool multiline, params GUIOption[] options)
         {
             Internal_CreateInstance(this, multiline, "", options);
@@ -50,12 +45,10 @@ namespace BansheeEngine
         /// Creates a new single-line text box element.
         /// </summary>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITextBox(string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, false, style, options);
@@ -65,8 +58,7 @@ namespace BansheeEngine
         /// Creates a new single-line text box element.
         /// </summary>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITextBox(params GUIOption[] options)
         {
             Internal_CreateInstance(this, false, "", options);

MBansheeEngine/GUI/GUITexture.cs

@@ -34,19 +34,15 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="scale">Scale mode to use when sizing the texture.
-        /// </param>
-        /// <param name="transparent">Determines should the texture be rendered with transparency active.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="scale">Scale mode to use when sizing the texture.</param>
+        /// <param name="transparent">Determines should the texture be rendered with transparency active.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, GUIImageScaleMode scale, bool transparent, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, scale, transparent, style, options);
@@ -55,15 +51,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="scale">Scale mode to use when sizing the texture.
-        /// </param>
-        /// <param name="transparent">Determines should the texture be rendered with transparency active.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="scale">Scale mode to use when sizing the texture.</param>
+        /// <param name="transparent">Determines should the texture be rendered with transparency active.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, GUIImageScaleMode scale, bool transparent, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, scale, transparent, "", options);
@@ -72,17 +65,14 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element. Texture will use the default StretchToFit scaling.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="transparent">Determines should the texture be rendered with transparency active.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="transparent">Determines should the texture be rendered with transparency active.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, bool transparent, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, GUIImageScaleMode.StretchToFit, transparent, style, options);
@@ -91,13 +81,11 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element. Texture will use the default StretchToFit scaling.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="transparent">Determines should the texture be rendered with transparency active.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="transparent">Determines should the texture be rendered with transparency active.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, bool transparent, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, GUIImageScaleMode.StretchToFit, transparent, "", options);
@@ -106,17 +94,14 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element with transparency active.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="scale">Scale mode to use when sizing the texture.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="scale">Scale mode to use when sizing the texture.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, GUIImageScaleMode scale, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, scale, true, style, options);
@@ -125,13 +110,11 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element with transparency active.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
-        /// <param name="scale">Scale mode to use when sizing the texture.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
+        /// <param name="scale">Scale mode to use when sizing the texture.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, GUIImageScaleMode scale, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, scale, true, "", options);
@@ -140,15 +123,13 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element with transparency active. Texture will use the default StretchToFit scaling.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, GUIImageScaleMode.StretchToFit, true, style, options);
@@ -157,11 +138,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new texture element with transparency active. Texture will use the default StretchToFit scaling.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
         /// <param name="options">Options that allow you to control how is the element  positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUITexture(SpriteTexture texture, params GUIOption[] options)
         {
             Internal_CreateInstance(this, texture, GUIImageScaleMode.StretchToFit, true, "", options);
@@ -170,8 +150,8 @@ namespace BansheeEngine
         /// <summary>
         /// Sets the texture to display.
         /// </summary>
-        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will be used.
-        /// </param>
+        /// <param name="texture">Texture to display. If this is null then the texture specified by the style will 
+        ///                       be used.</param>
         public void SetTexture(SpriteTexture texture)
         {
             Internal_SetTexture(mCachedPtr, texture);

MBansheeEngine/GUI/GUIToggle.cs

@@ -32,17 +32,14 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
-        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons together. 
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
+        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons 
+        ///                           together. </param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIToggle(GUIContent content, GUIToggleGroup toggleGroup, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, toggleGroup, style, options);
@@ -51,15 +48,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIToggle(GUIContent content, string style, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, null, style, options);
@@ -68,12 +62,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUIToggle(GUIContent content, string style)
         {
             Internal_CreateInstance(this, content, null, style, new GUIOption[0]);
@@ -82,11 +74,9 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIToggle(GUIContent content, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, null, "", options);
@@ -95,14 +85,12 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
-        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons together. 
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
+        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons 
+        ///                           together.</param>
         /// <param name="style">Optional style to use for the element. Style controls the look of the element, as well as 
-        /// default layout options. Style will be retrieved from the active GUISkin. If not specified default element style 
-        /// is used.
-        /// </param>
+        ///                     default layout options. Style will be retrieved from the active GUISkin. If not specified 
+        ///                     default element style is used.</param>
         public GUIToggle(GUIContent content, GUIToggleGroup toggleGroup, string style)
         {
             Internal_CreateInstance(this, content, toggleGroup, style, new GUIOption[0]);
@@ -111,13 +99,11 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new toggle button with the specified label.
         /// </summary>
-        /// <param name="content">Content to display on the button.
-        /// </param>
-        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons together. 
-        /// </param>
+        /// <param name="content">Content to display on the button.</param>
+        /// <param name="toggleGroup">Optional toggle group that is used for grouping multiple toggle buttons 
+        ///                           together.</param>
         /// <param name="options">Options that allow you to control how is the element positioned and sized. This will 
-        /// override any similar options set by style.
-        /// </param>
+        ///                       override any similar options set by style.</param>
         public GUIToggle(GUIContent content, GUIToggleGroup toggleGroup, params GUIOption[] options)
         {
             Internal_CreateInstance(this, content, toggleGroup, "", options);

MBansheeEngine/Math/BsRect3.cs

@@ -13,14 +13,11 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a new rectangle.
         /// </summary>
-        /// <param name="center">Origin of the rectangle. 
-        /// </param>
-        /// <param name="axes">Two axes that define orientation of the rectangle. Axes extend from the origin.
-        /// Axes should be normalized.
-        /// </param>
-        /// <param name="extents">Two extents that define the size of the rectangle. Extends should be
-        /// half the width/height as they are applied in both directions.
-        /// </param>
+        /// <param name="center">Origin of the rectangle. </param>
+        /// <param name="axes">Two axes that define orientation of the rectangle. Axes extend from the origin. Axes should 
+        ///                    be normalized.</param>
+        /// <param name="extents">Two extents that define the size of the rectangle. Extends should be half the width/height
+        ///                       as they are applied in both directions.</param>
         public Rect3(Vector3 center, Vector3[] axes, float[] extents)
         {
             this._center = center;

MBansheeEngine/Math/MathEx.cs

@@ -493,10 +493,8 @@ namespace BansheeEngine
         /// Clamps a value between two other values.
         /// </summary>
         /// <param name="value">Value to clamp.</param>
-        /// <param name="min">Minimum value of the range to clamp. Must be lower than <paramref name="max"/>
-        /// </param>
-        /// <param name="max">Maximum value of the range to clamp. Must be higher than <paramref name="min"/>
-        /// </param>
+        /// <param name="min">Minimum value of the range to clamp. Must be lower than <paramref name="max"/></param>
+        /// <param name="max">Maximum value of the range to clamp. Must be higher than <paramref name="min"/></param>
         /// <returns>Returns unchanged value if it is in valid range, otherwise returns value clamped to the range
         /// extremes. </returns>
         public static float Clamp(float value, float min, float max)
@@ -513,10 +511,8 @@ namespace BansheeEngine
         /// Clamps a value between two other values.
         /// </summary>
         /// <param name="value">Value to clamp.</param>
-        /// <param name="min">Minimum value of the range to clamp. Must be lower than <paramref name="max"/>
-        /// </param>
-        /// <param name="max">Maximum value of the range to clamp. Must be higher than <paramref name="min"/>
-        /// </param>
+        /// <param name="min">Minimum value of the range to clamp. Must be lower than <paramref name="max"/></param>
+        /// <param name="max">Maximum value of the range to clamp. Must be higher than <paramref name="min"/></param>
         /// <returns>Returns unchanged value if it is in valid range, otherwise returns value clamped to the range
         /// extremes. </returns>
         public static int Clamp(int value, int min, int max)
@@ -532,8 +528,7 @@ namespace BansheeEngine
         /// <summary>
         /// Clamps a value between zero and one.
         /// </summary>
-        /// <param name="value">Value to clamp.
-        // </param>
+        /// <param name="value">Value to clamp.</param>
         /// <returns>Returns unchanged value if it is in [0, 1] range, otherwise returns value clamped to the range. 
         /// </returns>
         public static float Clamp01(float value)

MBansheeEngine/Math/Quaternion.cs

@@ -262,13 +262,10 @@ namespace BansheeEngine
         /// <summary>
         /// Initializes the quaternion with rotation that rotates from one direction to another.
         /// </summary>
-        /// <param name="fromDirection">Rotation to start at.
-        /// </param>
-        /// <param name="toDirection">Rotation to end at.
-        /// </param>
+        /// <param name="fromDirection">Rotation to start at.</param>
+        /// <param name="toDirection">Rotation to end at.</param>
         /// <param name="fallbackAxis">Fallback axis to use if the from/to vectors are almost completely opposite.
-        /// Fallback axis should be perpendicular to both vectors.
-        /// </param>
+        ///                            Fallback axis should be perpendicular to both vectors.</param>
         public void SetFromToRotation(Vector3 fromDirection, Vector3 toDirection, Vector3 fallbackAxis)
         {
 		    fromDirection.Normalize();
@@ -377,14 +374,12 @@ namespace BansheeEngine
         /// Performs spherical interpolation between two quaternions. Spherical interpolation neatly interpolates between
         /// two rotations without modifying the size of the vector it is applied to (unlike linear interpolation).
         /// </summary>
-        /// <param name="from">Start quaternion.
-        /// </param>
-        /// <param name="to">End quaternion.
-        /// </param>
+        /// <param name="from">Start quaternion.</param>
+        /// <param name="to">End quaternion.</param>
         /// <param name="t">Interpolation factor in range [0, 1] that determines how much to interpolate between
         /// <paramref name="from"/> and <paramref name="to"/>.</param>
         /// <param name="shortestPath">Should the interpolation be performed between the shortest or longest path between
-        /// the two quaternions.</param>
+        ///                            the two quaternions.</param>
         /// <returns>Interpolated quaternion representing a rotation between <paramref name="from"/> and 
         /// <paramref name="to"/>.</returns>
         public static Quaternion Slerp(Quaternion from, Quaternion to, float t, bool shortestPath = false)
@@ -533,13 +528,10 @@ namespace BansheeEngine
         /// <summary>
         /// Creates a quaternion with rotation that rotates from one direction to another.
         /// </summary>
-        /// <param name="fromDirection">Rotation to start at.
-        /// </param>
-        /// <param name="toDirection">Rotation to end at.
-        /// </param>
+        /// <param name="fromDirection">Rotation to start at.</param>
+        /// <param name="toDirection">Rotation to end at.</param>
         /// <param name="fallbackAxis">Fallback axis to use if the from/to vectors are almost completely opposite.
-        /// Fallback axis should be perpendicular to both vectors.
-        /// </param>
+        ///                            Fallback axis should be perpendicular to both vectors.</param>
         /// <returns>Quaternion that rotates an object from <paramref name="fromDirection"/> to 
         /// <paramref name="toDirection"/></returns>
         public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection, Vector3 fallbackAxis)
@@ -676,7 +668,7 @@ namespace BansheeEngine
         /// <param name="yAngle">Yar angle of rotation.</param>
         /// <param name="zAngle">Roll angle of rotation.</param>
         /// <param name="order">The order in which rotations will be applied. Different rotations can be created depending
-        /// on the order.</param>
+        ///                     on the order.</param>
         /// <returns>Quaternion that can rotate an object to the specified angles.</returns>
         public static Quaternion FromEuler(Degree xAngle, Degree yAngle, Degree zAngle, 
             EulerAngleOrder order = EulerAngleOrder.YXZ)
@@ -709,7 +701,7 @@ namespace BansheeEngine
         /// </summary>
         /// <param name="euler">Euler angles in degrees.</param>
         /// <param name="order">The order in which rotations will be applied. Different rotations can be created depending
-        /// on the order.</param>
+        ///                     on the order.</param>
         /// <returns>Quaternion that can rotate an object to the specified angles.</returns>
         public static Quaternion FromEuler(Vector3 euler, EulerAngleOrder order = EulerAngleOrder.YXZ)
         {