Documentation

BansheeCore/Include/BsFontImportOptions.h

@@ -16,7 +16,7 @@ namespace BansheeEngine
 		FontImportOptions();
 
 		/**
-		 * @brief	Sets font sizes you wish to import. Sizes are in points.
+		 * @brief	Sets font sizes that are to be imported. Sizes are in points.
 		 */
 		void setFontSizes(const Vector<UINT32>& fontSizes) { mFontSizes = fontSizes; }
 
@@ -31,7 +31,7 @@ namespace BansheeEngine
 		void clearCharIndexRanges();
 
 		/**
-		 * @brief	Sets dots per inch scale to use when rendering the characters into the texture.
+		 * @brief	Sets dots per inch resolution to use when rendering the characters into the texture.
 		 */
 		void setDPI(UINT32 dpi) { mDPI = dpi; }
 
@@ -41,12 +41,12 @@ namespace BansheeEngine
 		void setAntialiasing(bool enabled) { mAntialiasing = enabled; }
 
 		/**
-		 * @brief	Gets the sizes that are to be imported.
+		 * @brief	Gets the sizes that are to be imported. Ranges are defined as unicode numbers.
 		 */
 		Vector<UINT32> getFontSizes() const { return mFontSizes; }
 
 		/**
-		 * @brief	Gets character index ranges to import.
+		 * @brief	Gets character index ranges to import. Ranges are defined as unicode numbers.
 		 */
 		Vector<std::pair<UINT32, UINT32>> getCharIndexRanges() const { return mCharIndexRanges; }
 

BansheeCore/Include/BsPlatform.h

@@ -96,8 +96,8 @@ namespace BansheeEngine
 
 	/**
 	 * @brief	Drop targets allow you to register a certain portion of a window as a drop target that
-	 *			accepts certain drop types. Accepted drop types are provided by the OS and include things
-	 *			like file and item dragging.
+	 *			accepts certain drop types from the OS (platform) specific drag and drop system. Accepted 
+	 *			drop types are provided by the OS and include things like file and item dragging.
 	 *
 	 *			You will receive events with the specified drop area as long as it is active.
 	 */

BansheeCore/Include/BsPrefab.h

@@ -32,7 +32,8 @@ namespace BansheeEngine
 
 		/**
 		 * @brief	Replaces the contents of this prefab with new contents
-		 *			from the provided object.
+		 *			from the provided object. Object will be automatically linked to
+		 *			this prefab, and its previous prefab link (if any) will be broken.
 		 */
 		void update(const HSceneObject& sceneObject);
 

BansheeCore/Include/BsPrefabUtility.h

@@ -6,7 +6,7 @@
 namespace BansheeEngine
 {
 	/**
-	 * @brief	Handles various prefab specific operations.
+	 * @brief	Performs various prefab specific operations.
 	 */
 	class BS_CORE_EXPORT PrefabUtility
 	{
@@ -35,10 +35,8 @@ namespace BansheeEngine
 
 	public:
 		/**
-		 * @brief	Updates all of the objects belonging to the same prefab instance
-		 *			as the provided object (if any). The update will remove any instance
-		 *			specific changes to the hierarchy and restore it to the exact copy of 
-		 *			linked prefab.
+		 * @brief	Remove any instance specific changes to the object or its hierarchy from the 
+		 *			provided prefab instance and restore it to the exact copy of the linked prefab.
 		 *
 		 * @param[in]	so	Object to revert.
 		 */

BansheeCore/Include/BsSceneObject.h

@@ -84,7 +84,8 @@ namespace BansheeEngine
 		String getPrefabLink() const;
 
 		/**
-		 * @brief	Breaks the link between this prefab instance and its prefab.
+		 * @brief	Breaks the link between this prefab instance and its prefab. Object will retain 
+		 *			all current values but will no longer be influenced by modifications to its parent prefab.
 		 */
 		void breakPrefabLink();
 

BansheeCore/Include/BsTextureImportOptions.h

@@ -16,7 +16,7 @@ namespace BansheeEngine
 		TextureImportOptions();
 
 		/**
-		 * @brief	Sets the pixel format that the imported texture will have.
+		 * @brief	Sets the pixel format to import as.
 		 */
 		void setFormat(PixelFormat format) { mFormat = format; }
 
@@ -43,7 +43,7 @@ namespace BansheeEngine
 		void setSRGB(bool sRGB) { mSRGB = sRGB; }
 
 		/**
-		 * @brief	Gets the pixel format that the imported texture will have.
+		 * @brief	Gets the pixel format to import as.
 		 */
 		PixelFormat getFormat() const { return mFormat; }
 

BansheeCore/Include/Win32/BsWin32FolderMonitor.h

@@ -21,8 +21,8 @@ namespace BansheeEngine
 	};
 
 	/**
-	 * @brief	Allows you to monitor a file system folder for changes. Depending on the flags
-	 *			set this monitor can notify you when file is changed/moved/renamed, etc.
+	 * @brief	Allows monitoring a file system folder for changes. Depending on the flags
+	 *			set this monitor can notify you when file is changed/moved/renamed and similar.
 	 */
 	class BS_CORE_EXPORT FolderMonitor
 	{
@@ -62,26 +62,25 @@ namespace BansheeEngine
 		void _update();
 
 		/**
-		 * @brief	Triggers when a file is modified. Provides
-		 *			full path to the file.
+		 * @brief	Triggers when a file in the monitored folder is modified. Provides absolute path to the file.
 		 */
 		Event<void(const Path&)> onModified;
 
 		/**
-		 * @brief	Triggers when a file/folder is adeed. Provides
-		 *			full path to the file/folder.
+		 * @brief	Triggers when a file/folder is added in the monitored folder. Provides
+		 *			absolute path to the file/folder.
 		 */
 		Event<void(const Path&)> onAdded;
 
 		/**
-		 * @brief	Triggers when a file/folder is removed. Provides
-		 *			full path to the file/folder.
+		 * @brief	Triggers when a file/folder is removed from the monitored folder. Provides
+		 *			absolute path to the file/folder.
 		 */
 		Event<void(const Path&)> onRemoved;
 
 		/**
-		 * @brief	Triggers when a file/folder is renamed. Provides
-		 *			full path to the old and new name.
+		 * @brief	Triggers when a file/folder is renamed in the monitored folder. 
+		 *			Provides absolute path with old and new names.
 		 */
 		Event<void(const Path&, const Path&)> onRenamed;
 

BansheeEngine/Include/BsGUIMenu.h

@@ -143,7 +143,7 @@ namespace BansheeEngine
 		 *						All sub-elements of a path will be added automatically.
 		 * @param	callback	Callback that triggers when the path element is selected.
 		 * @param	priority	Priority determines the position of the menu item relative to its siblings.
-		 *						Higher priority means it will be placed higher up in the menu.
+		 *						Higher priority means it will be placed earlier in the menu.
 		 * @param	key			Keyboard shortcut that can be used for triggering the menu item.
 		 *
 		 * @returns	A menu item object that you may use for removing the menu item later. Its lifetime is managed internally.
@@ -156,7 +156,7 @@ namespace BansheeEngine
 		 * @param	path		Path that determines where to add the element. See class information on how to specify paths.
 		 *						All sub-elements of a path will be added automatically.
 		 * @param	priority	Priority determines the position of the menu item relative to its siblings.
-		 *						Higher priority means it will be placed higher up in the menu.
+		 *						Higher priority means it will be placed earlier in the menu.
 		 *
 		 * @returns	A menu item object that you may use for removing the menu item later. Its lifetime is managed internally.
 		 */

BansheeEngine/Include/BsScriptCodeImportOptions.h

@@ -16,12 +16,12 @@ namespace BansheeEngine
 		ScriptCodeImportOptions();
 
 		/**
-		* @brief	Sets whether the script is editor-only, or a normal game script.
+		* @brief	Sets whether the script is editor-only or a normal game script.
 		*/
 		void setEditorScript(bool editorScript) { mEditorScript = editorScript; }
 
 		/**
-		 * @brief	Checks whether the script is editor-only, or a normal game script.
+		 * @brief	Checks whether the script is editor-only or a normal game script.
 		 */
 		bool isEditorScript() const { return mEditorScript; }
 

MBansheeEditor/EditorWindow.cs

@@ -5,24 +5,54 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Base class for all editor windows. Editor window can be docked on the main editor window or float as a separate 
+    /// window. User is allowed to reposition and resize the window as he wishes. Editor window GUI is fully customizable.
+    /// </summary>
     public class EditorWindow : ScriptObject
     {
+        /// <summary>
+        /// Width of the window in pixels.
+        /// </summary>
         public int Width { get { return Internal_GetWidth(mCachedPtr); } }
+
+        /// <summary>
+        /// Height of the window in pixels.
+        /// </summary>
         public int Height { get { return Internal_GetHeight(mCachedPtr); } }
+
+        /// <summary>
+        /// Determines whether the editor window currently has keyboard focus (has been clicked on most recently).
+        /// </summary>
         public bool HasFocus { get { return Internal_HasFocus(mCachedPtr); } }
 
         protected GUIPanel GUI;
 
+        /// <summary>
+        /// Opens an editor window. If window is already open it returns the existing instance.
+        /// </summary>
+        /// <typeparam name="T">Type of window to open.</typeparam>
+        /// <returns>Instance of the open window.</returns>
         public static T OpenWindow<T>() where T : EditorWindow
         {
             return (T)Internal_CreateOrGetInstance(typeof(T).Namespace, typeof(T).Name);
         }
 
+        /// <summary>
+        /// Retrieves instance of an open window.
+        /// </summary>
+        /// <typeparam name="T">Type of window to retrieve the instance of.</typeparam>
+        /// <returns>Instance of the winodow if it is open, null otherwise.</returns>
         public static T GetWindow<T>() where T : EditorWindow
         {
             return (T)Internal_GetInstance(typeof(T).Namespace, typeof(T).Name);
         }
 
+        /// <summary>
+        /// Converts coordinates in screen space to coordinates relative to the window.
+        /// </summary>
+        /// <param name="screenPos">Coordinates in screen space.</param>
+        /// <returns>Coordinates relative to the window.</returns>
         public Vector2I ScreenToWindowPos(Vector2I screenPos)
         {
             Vector2I windowPos;
@@ -30,6 +60,11 @@ namespace BansheeEditor
             return windowPos;
         }
 
+        /// <summary>
+        /// Converts coordinates relative to the window to screen space to coordinates.
+        /// </summary>
+        /// <param name="windowPos">Coordinates relative to the window.</param>
+        /// <returns>Coordinates in screen space.</returns>
         public Vector2I WindowToScreenPos(Vector2I windowPos)
         {
             Vector2I screenPos;
@@ -37,16 +72,29 @@ namespace BansheeEditor
             return screenPos;
         }
 
+        /// <summary>
+        /// Triggered whenever the window size ranges.
+        /// </summary>
+        /// <param name="width">New width of the window in pixels.</param>
+        /// <param name="height">New height of the window in pixels.</param>
         protected virtual void WindowResized(int width, int height)
         {
 
         }
 
+        /// <summary>
+        /// Triggered whenever the window gains or loses focus.
+        /// </summary>
+        /// <param name="inFocus">True if focus was gained, false otherwise.</param>
         protected virtual void FocusChanged(bool inFocus)
         {
             
         }
 
+        /// <summary>
+        /// Name of the window to display in the title bar.
+        /// </summary>
+        /// <returns>Name of the window to display in the title bar.</returns>
         protected virtual LocString GetDisplayName()
         {
             return GetType().Name;

MBansheeEditor/FolderMonitor.cs

@@ -8,41 +8,85 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Allows monitoring a file system folder for changes. Depending on the flags set this monitor can notify you when 
+    /// file is changed/moved/renamed and similar.
+    /// </summary>
     public class FolderMonitor : ScriptObject
     {
+        /// <summary>
+        /// Triggers when a file in the monitored folder is modified. Provides absolute path to the modified file.
+        /// </summary>
         public Action<string> OnModified;
+
+        /// <summary>
+        /// Triggers when a file/folder is added in the monitored folder. Provides absolute path to the added file/folder.
+        /// </summary>
         public Action<string> OnAdded;
+
+        /// <summary>
+        /// Triggers when a file/folder is removed from the monitored folder. Provides absolute path to the removed 
+        /// file/folder.
+        /// </summary>
         public Action<string> OnRemoved;
+
+        /// <summary>
+        /// Triggers when a file/folder is renamed in the monitored folder. Provides absolute path with old and new names.
+        /// </summary>
         public Action<string, string> OnRenamed;
 
+        /// <summary>
+        /// Constructs a new folder monitor instance that immediately starts monitor the provided folder.
+        /// </summary>
+        /// <param name="folderToMonitor">Absolute path to the folder to monitor.</param>
         public FolderMonitor(string folderToMonitor)
         {
             Internal_CreateInstance(this, folderToMonitor);
         }
 
+        /// <summary>
+        /// Stops monitoring the folder.
+        /// </summary>
         public void Destroy()
         {
             Internal_Destroy(mCachedPtr);
         }
 
+        /// <summary>
+        /// Triggered by the runtime when a file in the monitored folder is modified.
+        /// </summary>
+        /// <param name="path">Absolute path to the modified file/folder.</param>
         private void Internal_DoOnModified(string path)
         {
             if (OnModified != null)
                 OnModified(path);
         }
 
+        /// <summary>
+        /// Triggered by the runtime when a file in the monitored folder is added.
+        /// </summary>
+        /// <param name="path">Absolute path to the added file/folder.</param>
         private void Internal_DoOnAdded(string path)
         {
             if (OnAdded != null)
                 OnAdded(path);
         }
 
+        /// <summary>
+        /// Triggered by the runtime when a file in the monitored folder is removed.
+        /// </summary>
+        /// <param name="path">Absolute path to the removed file/folder.</param>
         private void Internal_DoOnRemoved(string path)
         {
             if (OnRemoved != null)
                 OnRemoved(path);
         }
 
+        /// <summary>
+        /// Triggered by the runtime when a file in the monitored folder is renamed.
+        /// </summary>
+        /// <param name="from">Absolute path to the original file/folder location.</param>
+        /// <param name="to">Absolute path to the new file/folder location.</param>
         private void Internal_DoOnRenamed(string from, string to)
         {
             if (OnRenamed != null)

MBansheeEditor/HierarchyWindow.cs

@@ -2,16 +2,23 @@
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Editor window that displays the scene hierarchy tree view, displaying all scene objects in the current scene.
+    /// </summary>
     public class HierarchyWindow : EditorWindow
     {
         private GUISceneTreeView treeView;
 
+        /// <summary>
+        /// Opens the hierarchy window.
+        /// </summary>
         [MenuItem("Windows/Hierarchy", ButtonModifier.CtrlAlt, ButtonCode.H, 6000)]
         private static void OpenHierarchyWindow()
         {
             OpenWindow<HierarchyWindow>();
         }
 
+        /// <inheritdoc/>
         protected override LocString GetDisplayName()
         {
             return new LocEdString("Hierarchy");

MBansheeEditor/ImportOptions.cs

@@ -4,30 +4,48 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Base class for all import options. Import options allow control over how is a specific resource type imported.
+    /// </summary>
     public class ImportOptions : ScriptObject
     {
 
     }
 
+    /// <summary>
+    /// Import options that provide various options for controlling how is a texture file imported.
+    /// </summary>
     public class TextureImportOptions : ImportOptions
     {
+        /// <summary>
+        /// Creates new texture import options with default values.
+        /// </summary>
         public TextureImportOptions()
         {
             Internal_CreateInstance(this);
         }
 
+        /// <summary>
+        /// Pixel format to import as.
+        /// </summary>
         public PixelFormat Format
         {
             get { return Internal_GetPixelFormat(mCachedPtr); }
             set { Internal_SetPixelFormat(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Determines whether the imported texture will have mipmaps generated.
+        /// </summary>
         public bool GenerateMipmaps
         {
             get { return Internal_GetGenerateMipmaps(mCachedPtr); }
             set { Internal_SetGenerateMipmaps(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Maximum mipmap level to generate, if mipmap generation is enabled.
+        /// </summary>
         public UInt32 MaxMipmapLevel
         {
             get { return Internal_GetMaxMipmapLevel(mCachedPtr); }
@@ -56,31 +74,49 @@ namespace BansheeEditor
         private static extern void Internal_SetMaxMipmapLevel(IntPtr thisPtr, UInt32 value);
     }
 
+    /// <summary>
+    /// Import options that provide various options for controlling how is a font file imported.
+    /// </summary>
     public class FontImportOptions : ImportOptions
     {
+        /// <summary>
+        /// Creates new font import options with default values.
+        /// </summary>
         public FontImportOptions()
         {
             Internal_CreateInstance(this);
         }
 
+        /// <summary>
+        /// Font sizes in points that are to be imported.
+        /// </summary>
         public UInt32[] FontSizes
         {
             get { return Internal_GetFontSizes(mCachedPtr); }
             set { Internal_SetFontSizes(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Dots per inch resolution to use when rendering the characters into the texture.
+        /// </summary>
         public UInt32 DPI
         {
             get { return Internal_GetDPI(mCachedPtr); }
             set { Internal_SetDPI(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Determines should rendered characters be antialiased.
+        /// </summary>
         public bool Antialiasing
         {
             get { return Internal_GetAntialiasing(mCachedPtr); }
             set { Internal_SetAntialiasing(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Determines character ranges to import from the font. Ranges are defined as unicode numbers.
+        /// </summary>
         public CharRange[] CharRanges
         {
             get { return Internal_GetCharRanges(mCachedPtr); }
@@ -115,13 +151,23 @@ namespace BansheeEditor
         private static extern void Internal_SetCharRanges(IntPtr thisPtr, CharRange[] value);
     }
 
+    /// <summary>
+    /// Import options that provide various options for controlling how is a script file imported.
+    /// </summary>
     public class ScriptCodeImportOptions : ImportOptions
     {
+        /// <summary>
+        /// Creates new script import options with default values.
+        /// </summary>
         public ScriptCodeImportOptions()
         {
             Internal_CreateInstance(this);
         }
 
+        /// <summary>
+        /// Determines whether the script is editor-only or a normal game script. Editor scripts are compiled in a separate
+        /// assembly and may reference editor specific functionality, but are not available in the final game code.
+        /// </summary>
         public bool EditorScript
         {
             get { return Internal_IsEditorScript(mCachedPtr); }

MBansheeEditor/Inspector/InspectorWindow.cs

@@ -309,7 +309,7 @@ namespace BansheeEditor
 
             soNameInput.Text = activeSO.Name;
 
-            bool hasPrefab = PrefabUtility.HasPrefabLink(activeSO);
+            bool hasPrefab = PrefabUtility.IsPrefabInstance(activeSO);
             if (soHasPrefab != hasPrefab || forceUpdate)
             {
                 int numChildren = soPrefabLayout.ChildCount;

MBansheeEditor/Library/LibraryDropTarget.cs

@@ -238,8 +238,8 @@ namespace BansheeEditor
         /// <summary>
         /// Triggered when an OS drag event has entered the drop target area.
         /// </summary>
-        /// <param name="x">X coordinate of the pointer relative to the drop target area.</param>
-        /// <param name="y">Y coordinate of the pointer relative to the drop target area.</param>
+        /// <param name="x">X coordinate of the pointer relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer relative to the parent window.</param>
         private void DoOnOSDragEnter(int x, int y)
         {
             isOSDragActive = true;
@@ -249,7 +249,7 @@ namespace BansheeEditor
         }
 
         /// <summary>
-        /// Triggered when an OS drag event has left the drop target area.
+        /// Triggered when an OS drag event has left the parent window.
         /// </summary>
         private void DoOnOSDragLeave()
         {
@@ -262,8 +262,8 @@ namespace BansheeEditor
         /// <summary>
         /// Triggered when a pointer moves while an OS drag event is occuring over the drop target area.
         /// </summary>
-        /// <param name="x">X coordinate of the pointer relative to the drop target area.</param>
-        /// <param name="y">Y coordinate of the pointer relative to the drop target area.</param>
+        /// <param name="x">X coordinate of the pointer relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer relative to the parent window.</param>
         private void DoOnOSDrag(int x, int y)
         {
             if (OnDrag != null)
@@ -273,8 +273,8 @@ namespace BansheeEditor
         /// <summary>
         /// Triggered when the pointer was released during an OS drag and drop operation while over the drop target area.
         /// </summary>
-        /// <param name="x">X coordinate of the pointer relative to the drop target area.</param>
-        /// <param name="y">Y coordinate of the pointer relative to the drop target area.</param>
+        /// <param name="x">X coordinate of the pointer relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer relative to the parent window.</param>
         private void DoOnOSDrop(int x, int y)
         {
             isOSDragActive = false;

MBansheeEditor/LocEdString.cs

@@ -7,6 +7,10 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Helper object that creates a localized string in the editor-specific string table. Allows easier separation between
+    /// editor and game string tables.
+    /// </summary>
     internal class LocEdString
     {
         // Note: This must match C++ HEString::ENGINE_STRING_TABLE_ID
@@ -14,21 +18,42 @@ namespace BansheeEditor
 
         private LocString internalString;
 
+        /// <summary>
+        /// Creates a new empty localized string in the editor string table.
+        /// </summary>
         public LocEdString()
         {
             internalString = new LocString(EDITOR_STRING_TABLE_ID);
         }
 
+        /// <summary>
+        /// Creates a new localized string with the specified identifier in the editor string table. If the identifier 
+        /// doesn't previously exist in the string table, identifier value will also be used for initializing the default 
+        /// language version of the string.
+        /// </summary>
+        /// <param name="identifier">String you can use for later referencing the localized string.</param>
         public LocEdString(string identifier)
         {
             internalString = new LocString(identifier, EDITOR_STRING_TABLE_ID);
         }
 
+        /// <summary>
+        /// Implicitly converts between an editor localized string and a normal localized string. The normal localized
+        /// string will still internally reference the editor string table, making it equivalent to the original editor
+        /// string aside from being different types.
+        /// </summary>
+        /// <param name="edString">Editor localized string to convert to normal localized string.</param>
+        /// <returns>Normal localized string referencing the editor string table.</returns>
         public static implicit operator LocString(LocEdString edString)
         {
             return edString.internalString;
         }
 
+        /// <summary>
+        /// Implicity converts between an editor localized string and GUI contents. 
+        /// </summary>
+        /// <param name="edString">Editor localized string to convert.</param>
+        /// <returns>GUI contents object that may be used for initializing various GUI elements.</returns>
         public static implicit operator GUIContent(LocEdString edString)
         {
             return new GUIContent(edString.internalString);

MBansheeEditor/MenuItem.cs

@@ -3,9 +3,30 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Adds an entry to the main menu bar. Clicking on that entry will trigger the method the attribute is attached to.
+    /// The method must be static, have no parameters or return values otherwise the attribute will be ignored.
+    /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
     public sealed class MenuItem : Attribute
     {
+        /// <summary>
+        /// Creates a new menu item attribute with a shortcut. Pressing the shortcut key or selecting the item in the menu
+        /// will trigger the menu item callback.
+        /// </summary>
+        /// <param name="path">Path that determines where in the menu to add the element. All path elements must be 
+        ///                    separated by /, e.g. "View/Toolbars/Find"</param>
+        /// <param name="shortcutModifier">Optional shortcut modifier that needs to be pressed along with the shortcut 
+        ///                                button in order to trigger the shortcut.</param>
+        /// <param name="shortcutKey">Shortcut key that will trigger the shortcut.</param>
+        /// <param name="priority">Priority determines the position of the menu item relative to its siblings.
+        ///                        Higher priority means it will be placed earlier in the menu.</param>
+        /// <param name="separator">Determines should a separator be inserted just before this element.</param>
+        /// <param name="contextCallback">Name of a method that returns a boolean determining whether the menu item callback
+        ///                               is allowed to trigger. This is useful if menu items are only valid in specific
+        ///                               situations (e.g. a scene object must be selected). The method must be static,
+        ///                               return a boolean value, accept no parameters and be in the same class as
+        ///                               the method this attribute is attached to.</param>
         public MenuItem(string path, ButtonModifier shortcutModifier, ButtonCode shortcutKey, int priority = 0, 
             bool separator = false, string contextCallback = null)
         {
@@ -16,6 +37,19 @@ namespace BansheeEditor
             this.contextCallback = contextCallback;
         }
 
+        /// <summary>
+        /// Creates a new menu item attribute. Selecting the item in the menu will trigger the menu item callback.
+        /// </summary>
+        /// <param name="path">Path that determines where in the menu to add the element. All path elements must be 
+        ///                    separated by /, e.g. "View/Toolbars/Find"</param>
+        /// <param name="priority">Priority determines the position of the menu item relative to its siblings.
+        ///                        Higher priority means it will be placed earlier in the menu.</param>
+        /// <param name="separator">Determines should a separator be inserted just before this element.</param>
+        /// <param name="contextCallback">Name of a method that returns a boolean determining whether the menu item callback
+        ///                               is allowed to trigger. This is useful if menu items are only valid in specific
+        ///                               situations (e.g. a scene object must be selected). The method must be static,
+        ///                               return a boolean value, accept no parameters and be in the same class as
+        ///                               the method this attribute is attached to.</param>
         public MenuItem(string path, int priority = 0, bool separator = false, string contextCallback = null)
         {
             this.path = path;

MBansheeEditor/MenuItems.cs

@@ -12,6 +12,9 @@ namespace BansheeEditor
     /// </summary>
     static class MenuItems
     {
+        /// <summary>
+        /// Adds a camera component to the currently selected scene object.
+        /// </summary>
         [MenuItem("Components/Camera", 7050)]
         private static void AddCamera()
         {
@@ -23,6 +26,9 @@ namespace BansheeEditor
             so.AddComponent<Camera>();
         }
 
+        /// <summary>
+        /// Adds a renderable component to the currently selected scene object.
+        /// </summary>
         [MenuItem("Components/Renderable", 7049)]
         private static void AddRenderable()
         {
@@ -34,6 +40,9 @@ namespace BansheeEditor
             so.AddComponent<Renderable>();
         }
 
+        /// <summary>
+        /// Adds a point light component to the currently selected scene object.
+        /// </summary>
         [MenuItem("Components/Point light", 7048)]
         private static void AddPointLight()
         {
@@ -46,6 +55,9 @@ namespace BansheeEditor
             light.Type = LightType.Point;
         }
 
+        /// <summary>
+        /// Adds a spot light component to the currently selected scene object.
+        /// </summary>
         [MenuItem("Components/Spot light", 7047)]
         private static void AddSpotLight()
         {
@@ -58,6 +70,9 @@ namespace BansheeEditor
             light.Type = LightType.Spot;
         }
 
+        /// <summary>
+        /// Adds a directional light component to the currently selected scene object.
+        /// </summary>
         [MenuItem("Components/Directional light", 7046)]
         private static void AddDirectionalLight()
         {
@@ -70,6 +85,9 @@ namespace BansheeEditor
             light.Type = LightType.Directional;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a camera component.
+        /// </summary>
         [MenuItem("Scene Objects/Camera", 8050)]
         private static void AddCameraSO()
         {
@@ -79,6 +97,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a renderable component.
+        /// </summary>
         [MenuItem("Scene Objects/Renderable", 8049)]
         private static void AddRenderableSO()
         {
@@ -88,6 +109,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a point light component.
+        /// </summary>
         [MenuItem("Scene Objects/Point light", 8048)]
         private static void AddPointLightSO()
         {
@@ -98,6 +122,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a spot light component.
+        /// </summary>
         [MenuItem("Scene Objects/Spot light", 8047)]
         private static void AddSpotLightSO()
         {
@@ -108,6 +135,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a directional light component.
+        /// </summary>
         [MenuItem("Scene Objects/Directional light", 8046)]
         private static void AddDirectionalLightSO()
         {
@@ -118,6 +148,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a box primitive.
+        /// </summary>
         [MenuItem("Scene Objects/3D primitives/Box", 8100)]
         private static void Add3DBox()
         {
@@ -128,6 +161,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a sphere primitive.
+        /// </summary>
         [MenuItem("Scene Objects/3D primitives/Sphere", 8099)]
         private static void Add3DSphere()
         {
@@ -138,6 +174,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a cone primitive.
+        /// </summary>
         [MenuItem("Scene Objects/3D primitives/Cone", 8098)]
         private static void Add3DCone()
         {
@@ -148,6 +187,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a quad primitive.
+        /// </summary>
         [MenuItem("Scene Objects/3D primitives/Quad", 8097)]
         private static void Add3DQuad()
         {
@@ -158,6 +200,9 @@ namespace BansheeEditor
             Selection.sceneObject = so;
         }
 
+        /// <summary>
+        /// Creates a new scene object with a disc primitive.
+        /// </summary>
         [MenuItem("Scene Objects/3D primitives/Disc", 8096)]
         private static void Add3DDisc()
         {

MBansheeEditor/ModalWindow.cs

@@ -5,14 +5,25 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Base implementation of a window that when open doesn't allow you to interact with other windows. Modal windows 
+    /// are similar to editor windows but cannot be docked, and are meant to be used for temporary operations like dialog 
+    /// boxes and progress bars.
+    /// </summary>
     public class ModalWindow : ScriptObject
     {
+        /// <summary>
+        /// Width of the window in pixels.
+        /// </summary>
         public int Width
         {
             get { return Internal_GetWidth(mCachedPtr); }
             set { Internal_SetWidth(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Height of the window in pixels.
+        /// </summary>
         public int Height
         {
             get { return Internal_GetHeight(mCachedPtr); }
@@ -21,16 +32,28 @@ namespace BansheeEditor
 
         protected GUIPanel GUI;
 
+        /// <summary>
+        /// Constructor for internal use by the runtime.
+        /// </summary>
         protected ModalWindow()
         {
             Internal_CreateInstance(this, false);
         }
 
+        /// <summary>
+        /// Creates a new modal window.
+        /// </summary>
+        /// <param name="allowCloseButton">Should the close button be displayed.</param>
         protected ModalWindow(bool allowCloseButton)
         {
             Internal_CreateInstance(this, allowCloseButton);
         }
 
+        /// <summary>
+        /// Converts coordinates in screen space to coordinates relative to the window.
+        /// </summary>
+        /// <param name="screenPos">Coordinates in screen space.</param>
+        /// <returns>Coordinates relative to the window.</returns>
         protected Vector2I ScreenToWindowPos(Vector2I screenPos)
         {
             Vector2I windowPos;
@@ -38,6 +61,11 @@ namespace BansheeEditor
             return windowPos;
         }
 
+        /// <summary>
+        /// Converts coordinates relative to the window to screen space to coordinates.
+        /// </summary>
+        /// <param name="windowPos">Coordinates relative to the window.</param>
+        /// <returns>Coordinates in screen space.</returns>
         protected Vector2I WindowToScreenPos(Vector2I windowPos)
         {
             Vector2I screenPos;
@@ -45,16 +73,27 @@ namespace BansheeEditor
             return screenPos;
         }
 
+        /// <summary>
+        /// Triggered whenever the window size ranges.
+        /// </summary>
+        /// <param name="width">New width of the window in pixels.</param>
+        /// <param name="height">New height of the window in pixels.</param>
         protected virtual void OnWindowResized(int width, int height)
         {
 
         }
 
+        /// <summary>
+        /// Closes the modal window.
+        /// </summary>
         protected void Close()
         {
             Internal_Close(mCachedPtr);
         }
 
+        /// <summary>
+        /// Allows you to set the mame of the window to display in the title bar.
+        /// </summary>
         public LocString Title
         {
             set { Internal_SetTitle(mCachedPtr, value); }

MBansheeEditor/OSDropTarget.cs

@@ -4,52 +4,105 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Drop targets allow you to register a certain portion of a window as a drop target that accepts file drops from the
+    /// OS (platform) specific drag and drop system. You will receive events with the specified drop area as long as it is 
+    /// active.
+    /// </summary>
     public class OSDropTarget : ScriptObject
     {
+        /// <summary>
+        /// Triggered when the user completes a drop while pointer is over the drop area. Provides window coordinates of 
+        /// the pointer position.
+        /// </summary>
         public Action<int, int> OnDrop;
+
+        /// <summary>
+        /// Triggered when a pointer enters the drop area. Provides window coordinates of the pointer position.
+        /// </summary>
         public Action<int, int> OnEnter;
+
+        /// <summary>
+        /// Triggered when a pointer leaves the drop area.
+        /// </summary>
         public Action OnLeave;
+
+        /// <summary>
+        /// Triggered when a pointer is being dragged over the drop area. Provides window coordinates of the pointer 
+        /// position.
+        /// </summary>
         public Action<int, int> OnDrag;
 
+        /// <summary>
+        /// Creates a new OS drop target.
+        /// </summary>
+        /// <param name="window">Window on which the drop target is on.</param>
         public OSDropTarget(EditorWindow window)
         {
             IntPtr nativeWindow = window.GetCachedPtr();;
             Internal_CreateInstance(this, nativeWindow);
         }
 
+        /// <summary>
+        /// Destroys the drop target, stopping any further events.
+        /// </summary>
         public void Destroy()
         {
             Internal_Destroy(mCachedPtr);
         }
 
+        /// <summary>
+        /// Allows you to set the drop target bounds, relative to the parent window.
+        /// </summary>
         public Rect2I Bounds
         {
             set { Internal_SetBounds(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Returns a list of files received by the drop target. Only valid after a drop has been triggered.
+        /// </summary>
         public string[] FilePaths
         {
             get { return Internal_GetFilePaths(mCachedPtr); }
         }
 
+        /// <summary>
+        /// Triggered internally by the runtime when a pointer enters the drop area.
+        /// </summary>
+        /// <param name="x">X coordinate of the pointer position, relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer position, relative to the parent window.</param>
         private void InternalDoOnEnter(int x, int y)
         {
             if (OnEnter != null)
                 OnEnter(x, y);
         }
 
+        /// <summary>
+        /// Triggered internally by the runtime when a pointer leaves the drop area.
+        /// </summary>
         private void InternalDoOnLeave()
         {
             if (OnLeave != null)
                 OnLeave();
         }
 
+        /// <summary>
+        /// Triggered internally by the runtime when a pointer is being dragged over the drop area.
+        /// </summary>
+        /// <param name="x">X coordinate of the pointer position, relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer position, relative to the parent window.</param>
         private void InternalDoOnDrag(int x, int y)
         {
             if (OnDrag != null)
                 OnDrag(x, y);
         }
 
+        /// <summary>
+        /// Triggered internally by the runtime when the user completes a drop while pointer is over the drop area.
+        /// </summary>
+        /// <param name="x">X coordinate of the pointer position, relative to the parent window.</param>
+        /// <param name="y">Y coordinate of the pointer position, relative to the parent window.</param>
         private void InternalDoOnDrop(int x, int y)
         {
             if (OnDrop != null)

MBansheeEditor/PrefabUtility.cs

@@ -8,8 +8,16 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Performs various prefab specific operations.
+    /// </summary>
     public static class PrefabUtility
     {
+        /// <summary>
+        /// Breaks the link between a prefab instance and its prefab. Object will retain all current values but will
+        /// no longer be influenced by modifications to its parent prefab.
+        /// </summary>
+        /// <param name="obj">Prefab instance whose link to break.</param>
         public static void BreakPrefab(SceneObject obj)
         {
             if (obj == null)
@@ -19,6 +27,12 @@ namespace BansheeEditor
             Internal_BreakPrefab(objPtr);
         }
 
+
+        /// <summary>
+        /// Updates the contents of the prefab with the contents of the provided prefab instance. If the provided object
+        /// is not a prefab instance nothing happens.
+        /// </summary>
+        /// <param name="obj">Prefab instance whose prefab to update.</param>
         public static void ApplyPrefab(SceneObject obj)
         {
             if (obj == null)
@@ -28,6 +42,11 @@ namespace BansheeEditor
             Internal_ApplyPrefab(objPtr);
         }
 
+        /// <summary>
+        /// Remove any instance specific changes to the object or its hierarchy from the provided prefab instance and 
+        /// restore it to the exact copy of the linked prefab.
+        /// </summary>
+        /// <param name="obj">Prefab instance to revert to original state.</param>
         public static void RevertPrefab(SceneObject obj)
         {
             if (obj == null)
@@ -37,7 +56,13 @@ namespace BansheeEditor
             Internal_RevertPrefab(objPtr);
         }
 
-        public static bool HasPrefabLink(SceneObject obj)
+        /// <summary>
+        /// Checks if a scene object has a prefab link. Scene objects with a prefab link will be automatically updated
+        /// when their prefab changes in order to reflect its changes.
+        /// </summary>
+        /// <param name="obj">Scene object to check if it has a prefab link.</param>
+        /// <returns>True if the object is a prefab instance (has a prefab link), false otherwise.</returns>
+        public static bool IsPrefabInstance(SceneObject obj)
         {
             if (obj == null)
                 return false;