Documentation

MBansheeEditor/EditorApplication.cs

@@ -6,6 +6,9 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Available tools in the scene view.
+    /// </summary>
     public enum SceneViewTool
     {
         View,
@@ -14,69 +17,125 @@ namespace BansheeEditor
         Scale
     }
 
+    /// <summary>
+    /// Pivot mode used by the scene view tools.
+    /// </summary>
     public enum HandlePivotMode
     {
         Center,
         Pivot
     }
 
+    /// <summary>
+    /// Coordinate mode used by the scene view tools.
+    /// </summary>
     public enum HandleCoordinateMode
     {
         Local,
         World
     }
 
-    public enum EditorPlatformType
-    {
-        Windows
-    }
-
+    /// <summary>
+    /// Manages various generic and global settings relating to the editor.
+    /// </summary>
     public class EditorApplication
     {
+        /// <summary>
+        /// Determines the active tool shown in the scene view.
+        /// </summary>
         public static SceneViewTool ActiveSceneTool
         {
             get { return EditorSettings.ActiveSceneTool; }
             set { EditorSettings.ActiveSceneTool = value; }
         }
 
+        /// <summary>
+        /// Determines the coordinate mode used by the tools in the scene view.
+        /// </summary>
         public static HandleCoordinateMode ActiveCoordinateMode
         {
             get { return EditorSettings.ActiveCoordinateMode; }
             set { EditorSettings.ActiveCoordinateMode = value; }
         }
 
+        /// <summary>
+        /// Determines the pivot mode used by the tools in the scene view.
+        /// </summary>
         public static HandlePivotMode ActivePivotMode
         {
             get { return EditorSettings.ActivePivotMode; }
             set { EditorSettings.ActivePivotMode = value; }
         }
 
+        /// <summary>
+        /// Camera used for rendering the scene view.
+        /// </summary>
         public static Camera SceneViewCamera
         {
             get { return EditorWindow.GetWindow<SceneWindow>().Camera; }
         }
 
-        public static EditorPlatformType EditorPlatform
-        {
-            get { return EditorPlatformType.Windows; } // TODO - Set this properly once we have support for more platforms
-        }
-
+        /// <summary>
+        /// Absolute path to the folder containing the currently open project.
+        /// </summary>
         public static string ProjectPath { get { return Internal_GetProjectPath(); } }
+
+        /// <summary>
+        /// Name of the currently open project.
+        /// </summary>
         public static string ProjectName { get { return Internal_GetProjectName(); } }
+
+        /// <summary>
+        /// Checks is any project currently loaded.
+        /// </summary>
         public static bool IsProjectLoaded { get { return Internal_GetProjectLoaded(); } }
+
+        /// <summary>
+        /// Returns the path where the script compiler is located at.
+        /// </summary>
         internal static string CompilerPath { get { return Internal_GetCompilerPath(); } }
+
+        /// <summary>
+        /// Returns the path to the folder where the builtin script assemblies are located at.
+        /// </summary>
         internal static string BuiltinAssemblyPath { get { return Internal_GetBuiltinAssemblyPath(); } }
+
+        /// <summary>
+        /// Returns the path to the folder where the custom script assemblies are located at.
+        /// </summary>
         internal static string ScriptAssemblyPath { get { return Internal_GetScriptAssemblyPath(); } }
+
+        /// <summary>
+        /// Returns the path to the folder where the .NET framework assemblies are located at.
+        /// </summary>
         internal static string FrameworkAssemblyPath { get { return Internal_GetFrameworkAssemblyPath(); } }
+
+        /// <summary>
+        /// Name of the builtin assembly containing engine specific types.
+        /// </summary>
         internal static string EngineAssembly { get { return Internal_GetEngineAssemblyName(); } }
+
+        /// <summary>
+        /// Name of the builtin assembly containing editor specific types.
+        /// </summary>
         internal static string EditorAssembly { get { return Internal_GetEditorAssemblyName(); } }
+
+        /// <summary>
+        /// Name of the custom assembly compiled from non-editor scripts within the project.
+        /// </summary>
         internal static string ScriptGameAssembly { get { return Internal_GetScriptGameAssemblyName(); } }
+
+        /// <summary>
+        /// Name of the custom assembly compiled from editor scripts within the project.
+        /// </summary>
         internal static string ScriptEditorAssembly { get { return Internal_GetScriptEditorAssemblyName(); } }
 
         private static EditorApplication instance;
-
         private static FolderMonitor monitor;
 
+        /// <summary>
+        /// Constructs a new editor application. Called at editor start-up by the runtime.
+        /// </summary>
         internal EditorApplication()
         {
             instance = this;
@@ -105,30 +164,27 @@ namespace BansheeEditor
             inputConfig.RegisterButton(SceneWindow.DuplicateBinding, ButtonCode.D, ButtonModifier.Ctrl);
         }
 
-        private static void OnEditorLoad()
-        {
-            if (EditorSettings.AutoLoadLastProject)
-            {
-                string projectPath = EditorSettings.LastOpenProject;
-                if (Internal_IsValidProject(projectPath))
-                    LoadProject(projectPath);
-                else
-                    ProjectWindow.Open();
-            }
-            else
-                ProjectWindow.Open();
-        }
-
+        /// <summary>
+        /// Triggered when the folder monitor detects an asset in the monitored folder was modified.
+        /// </summary>
+        /// <param name="path">Path to the modified file or folder.</param>
         private static void OnAssetModified(string path)
         {
             ProjectLibrary.Refresh(path);
         }
 
+        /// <summary>
+        /// Called 60 times per second by the runtime.
+        /// </summary>
         internal void OnEditorUpdate()
         {
             ProjectLibrary.Update();
         }
 
+        /// <summary>
+        /// Opens a dialog that allows the user to select a new prefab to load as the current scene. If current scene
+        /// is modified the user is offered a chance to save it.
+        /// </summary>
         [MenuItem("File/Open Scene", ButtonModifier.Ctrl, ButtonCode.L, 10050, true)]
         private static void LoadScene()
         {
@@ -140,6 +196,10 @@ namespace BansheeEditor
             }
         }
 
+        /// <summary>
+        /// Opens a dialog to allows the user to select a location where to save the current scene. If scene was previously
+        /// saved it is instead automatically saved at the last location.
+        /// </summary>
         [MenuItem("File/Save Scene", ButtonModifier.Ctrl, ButtonCode.S, 10049)]
         private static void SaveScene()
         {
@@ -152,6 +212,9 @@ namespace BansheeEditor
                 SaveSceneAs();
         }
 
+        /// <summary>
+        /// Opens a dialog to allows the user to select a location where to save the current scene.
+        /// </summary>
         [MenuItem("File/Save Scene As", 10048)]
         private static void SaveSceneAs()
         {
@@ -171,6 +234,11 @@ namespace BansheeEditor
             }
         }
 
+        /// <summary>
+        /// Loads a prefab as the current scene at the specified path. If current scene is modified the user is offered a 
+        /// chance to save it.
+        /// </summary>
+        /// <param name="path">Path to a valid prefab, relative to the resource folder.</param>
         public static void LoadScene(string path)
         {
             Action<string> continueLoad =
@@ -203,22 +271,38 @@ namespace BansheeEditor
                 continueLoad(path);
         }
 
+        /// <summary>
+        /// Checks does the folder at the provieded path contain a valid project.
+        /// </summary>
+        /// <param name="path">Absolute path to the root project folder.</param>
+        /// <returns>True if the folder contains a valid project.</returns>
         public static bool IsValidProject(string path)
         {
             return Internal_IsValidProject(path);
         }
 
+        /// <summary>
+        /// Contains a new project in the provided folder.
+        /// </summary>
+        /// <param name="path">Absolute path to the folder to create the project in. Name of this folder will be used as the
+        ///                    project's name.</param>
         public static void CreateProject(string path)
         {
             Internal_CreateProject(path);
         }
 
+        /// <summary>
+        /// Opens a Project Window allowing you to browse for or create a project.
+        /// </summary>
         [MenuItem("File/Open Project", 10100)]
         public static void BrowseForProject()
         {
             ProjectWindow.Open();
         }
 
+        /// <summary>
+        /// Saves all data in the currently open project.
+        /// </summary>
         [MenuItem("File/Save Project", 10099)]
         public static void SaveProject()
         {
@@ -227,7 +311,11 @@ namespace BansheeEditor
             Internal_SaveProject();
         }
 
-        // Note: Async, runs next frame
+        /// <summary>
+        /// Loads the project at the specified path. This method executes asynchronously and will trigger 
+        /// <see cref="OnProjectLoaded"/> when done.
+        /// </summary>
+        /// <param name="path">Absolute path to the project's root folder.</param>
         public static void LoadProject(string path)
         {
             if (IsProjectLoaded && path == ProjectPath)
@@ -254,6 +342,9 @@ namespace BansheeEditor
             Internal_OpenExternally(path);
         }
 
+        /// <summary>
+        /// Triggered when <see cref="LoadProject"/> method completes.
+        /// </summary>
         private static void OnProjectLoaded()
         {
             if (!IsProjectLoaded)
@@ -304,6 +395,10 @@ namespace BansheeEditor
                 Scene.Load(ProjectSettings.LastOpenScene);
         }
 
+        /// <summary>
+        /// Unloads the currently loaded project. Offers the user a chance to save the current scene if it is modified.
+        /// Automatically saves all project data before unloading.
+        /// </summary>
         private static void UnloadProject()
         {
             Action continueUnload =

MBansheeEditor/EditorBuiltin.cs

@@ -3,30 +3,50 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Contains various editor-specific resources that are always available.
+    /// </summary>
     public static class EditorBuiltin
     {
+        /// <summary>Icon used for displaying folders in the library window.</summary>
         public static SpriteTexture FolderIcon { get { return Internal_GetFolderIcon(); } }
+
+        /// <summary>Icon used for displaying mesh resources in the library window.</summary>
         public static SpriteTexture MeshIcon { get { return Internal_GetMeshIcon(); } }
+
+        /// <summary>Icon used for displaying font resources in the library window.</summary>
         public static SpriteTexture FontIcon { get { return Internal_GetFontIcon(); } }
+
+        /// <summary>Icon used for displaying texture resources in the library window.</summary>
         public static SpriteTexture TextureIcon { get { return Internal_GetTextureIcon(); } }
+
+        /// <summary>Icon used for displaying plain text resources in the library window.</summary>
         public static SpriteTexture PlainTextIcon { get { return Internal_GetPlainTextIcon(); } }
+
+        /// <summary>Icon used for displaying script code resources in the library window.</summary>
         public static SpriteTexture ScriptCodeIcon { get { return Internal_GetScriptCodeIcon(); } }
+
+        /// <summary>Icon used for displaying shader resources in the library window.</summary>
         public static SpriteTexture ShaderIcon { get { return Internal_GetShaderIcon(); } }
+
+        /// <summary>Icon used for displaying shader include resources in the library window.</summary>
         public static SpriteTexture ShaderIncludeIcon { get { return Internal_GetShaderIncludeIcon(); } }
+
+        /// <summary>Icon used for displaying material resources in the library window.</summary>
         public static SpriteTexture MaterialIcon { get { return Internal_GetMaterialIcon(); } }
+
+        /// <summary>Icon used for displaying sprite texture resources in the library window.</summary>
         public static SpriteTexture SpriteTextureIcon { get { return Internal_GetSpriteTextureIcon(); } }
+
+        /// <summary>Icon used for displaying prefab resources in the library window.</summary>
         public static SpriteTexture PrefabIcon { get { return Internal_GetPrefabIcon(); } }
 
         public static SpriteTexture XBtnIcon { get { return Internal_GetXBtnIcon(); } }
 
-        /// <summary>
-        /// Returns text contained in the default "empty" shader.
-        /// </summary>
+        /// <summary>Returns text contained in the default "empty" shader.</summary>
         public static string EmptyShaderCode { get { return Internal_GetEmptyShaderCode(); } }
 
-        /// <summary>
-        /// Returns text contained in the default "empty" C# script.
-        /// </summary>
+        /// <summary>Returns text contained in the default "empty" C# script.</summary>
         public static string EmptyCSScriptCode { get { return Internal_GetEmptyCSScriptCode(); } }
 
         [MethodImpl(MethodImplOptions.InternalCall)]

MBansheeEditor/EditorSettings.cs

@@ -10,68 +10,108 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Contains various settings that are applied globally to the editor. Settings will persist through editor sessions.
+    /// </summary>
     internal static class EditorSettings
     {
+        /// <summary>
+        /// Determines if snapping for move handle is active. When active the move handle can only be moved in increments
+        /// specified by <see cref="MoveHandleSnapAmount"/>.
+        /// </summary>
         public static bool MoveHandleSnapActive
         {
             get { return Internal_GetMoveHandleSnapActive(); }
             set { Internal_SetMoveHandleSnapActive(value); }
         }
 
+        /// <summary>
+        /// Determines if snapping for rotate handle is active. When active the rotate handle can only be rotated in 
+        /// increments specified by <see cref="RotateHandleSnapAmount"/>.
+        /// </summary>
         public static bool RotateHandleSnapActive
         {
             get { return Internal_GetRotateHandleSnapActive(); }
             set { Internal_SetRotateHandleSnapActive(value); }
         }
 
+        /// <summary>
+        /// Determines size of the increments the move handle can be moved when <see cref="MoveHandleSnapActive"/> is
+        /// active.
+        /// </summary>
         public static float MoveHandleSnapAmount
         {
             get { return Internal_GetMoveHandleSnapAmount(); }
             set { Internal_SetMoveHandleSnapAmount(value); }
         }
 
+        /// <summary>
+        /// Determines size of the increments the rotate handle can be moved when <see cref="RotateHandleSnapActive"/> is
+        /// active.
+        /// </summary>
         public static Degree RotateHandleSnapAmount
         {
             get { return Internal_GetRotateHandleSnapAmount(); }
             set { Internal_SetRotateHandleSnapAmount(value.Degrees); }
         }
 
+        /// <summary>
+        /// Determines the default size for all handles.
+        /// </summary>
         public static float DefaultHandleSize
         {
             get { return Internal_GetDefaultHandleSize(); }
             set { Internal_SetDefaultHandleSize(value); }
         }
 
+        /// <summary>
+        /// Determines the active tool shown in the scene view.
+        /// </summary>
         public static SceneViewTool ActiveSceneTool
         {
             get { return (SceneViewTool)Internal_GetActiveSceneTool(); }
             set { Internal_SetActiveSceneTool((int)value); }
         }
 
+        /// <summary>
+        /// Determines the coordinate mode used by the tools in the scene view.
+        /// </summary>
         public static HandleCoordinateMode ActiveCoordinateMode
         {
             get { return (HandleCoordinateMode)Internal_GetActiveCoordinateMode(); }
             set { Internal_SetActiveCoordinateMode((int)value); }
         }
 
+        /// <summary>
+        /// Determines the pivot mode used by the tools in the scene view.
+        /// </summary>
         public static HandlePivotMode ActivePivotMode
         {
             get { return (HandlePivotMode)Internal_GetActivePivotMode(); }
             set { Internal_SetActivePivotMode((int)value); }
         }
 
+        /// <summary>
+        /// Contains the absolute path to the last open project, if any.
+        /// </summary>
         public static string LastOpenProject
         {
             get { return Internal_GetLastOpenProject(); }
             set { Internal_SetLastOpenProject(value); }
         }
 
+        /// <summary>
+        /// Determines should the last open project be automatically loaded on editor startup.
+        /// </summary>
         public static bool AutoLoadLastProject
         {
             get { return Internal_GetAutoLoadLastProject(); }
             set { Internal_SetAutoLoadLastProject(value); }
         }
 
+        /// <summary>
+        /// Contains a list of most recently loaded projects.
+        /// </summary>
         public static RecentProject[] RecentProjects
         {
             get
@@ -107,66 +147,129 @@ namespace BansheeEditor
             }
         }
 
+        /// <summary>
+        /// Contains a hash value that is updated whenever one of the properties in this object is updated. This allows
+        /// external systems to track when they might need to reload the settings.
+        /// </summary>
         public static int Hash
         {
             get { return Internal_GetHash(); }
         }
 
+        /// <summary>
+        /// Sets a generic floating point property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetFloat(string name, float value)
         {
             Internal_SetFloat(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic integer property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetInt(string name, int value)
         {
             Internal_SetInt(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic boolean property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetBool(string name, bool value)
         {
             Internal_SetBool(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic string property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetString(string name, String value)
         {
             Internal_SetString(name, value);
         }
 
+        /// <summary>
+        /// Retrieves a generic floating point property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static float GetFloat(string name, float defaultValue = 0.0f)
         {
             return Internal_GetFloat(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic integer property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static int GetInt(string name, int defaultValue = 0)
         {
             return Internal_GetInt(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic boolean property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static bool GetBool(string name, bool defaultValue = false)
         {
             return Internal_GetBool(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic string property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static String GetString(string name, string defaultValue = "")
         {
             return Internal_GetString(name, defaultValue);
         }
 
+        /// <summary>
+        /// Checks does a generic property with the specified name exists.
+        /// </summary>
+        /// <param name="name">Name of the property to check.</param>
+        /// <returns>True if the property exists, false otherwise.</returns>
         public static bool HasKey(string name)
         {
             return Internal_HasKey(name);
         }
 
+        /// <summary>
+        /// Deletes a generic property with the specified name.
+        /// </summary>
+        /// <param name="name">Name of the property to delete.</param>
         public static void DeleteKey(string name)
         {
             Internal_DeleteKey(name);
         }
 
+        /// <summary>
+        /// Deletes all generic properties.
+        /// </summary>
         public static void DeleteAllKeys()
         {
             Internal_DeleteAllKeys();
         }
 
+        /// <summary>
+        /// Saves editor settings to the disk.
+        /// </summary>
         public static void Save()
         {
             Internal_Save();
@@ -258,10 +361,17 @@ namespace BansheeEditor
         private static extern void Internal_Save();
     }
 
-    // Note: Must match C++ struct RecentProject
+    /// <summary>
+    /// Contains data about a recently opened project.
+    /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    public struct RecentProject
+    public struct RecentProject // Note: Must match C++ struct RecentProject
     {
+        /// <summary>
+        /// Constructs a new recently opened project object.
+        /// </summary>
+        /// <param name="path">Absolute path to the project.</param>
+        /// <param name="timestamp">Timestamp when the project was last opened.</param>
         public RecentProject(string path, UInt64 timestamp)
         {
             this.path = path;

MBansheeEditor/EditorStyles.cs

@@ -6,6 +6,10 @@ using System.Threading.Tasks;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Contains various editor specific GUI style names. You may use these to customize look and feel of various GUI 
+    /// elements.
+    /// </summary>
     public static class EditorStyles
     {
         public const string Blank = "Blank";

MBansheeEditor/EditorUtility.cs

@@ -4,8 +4,17 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Contains various utility methods used throughout the editor.
+    /// </summary>
     public class EditorUtility
     {
+        /// <summary>
+        /// Calculates the axis aligned box that encapsulated the provided scene object and its components and children. 
+        /// Only certain components like <see cref="Renderable"/> will be included in bound calculations.
+        /// </summary>
+        /// <param name="so">Scene object to calculate the bounds for.</param>
+        /// <returns>Axis aligned box encompassing all scene object elements, in world space.</returns>
         public static AABox CalculateBounds(SceneObject so)
         {
             AABox bounds;
@@ -13,6 +22,12 @@ namespace BansheeEditor
             return bounds;
         }
 
+        /// <summary>
+        /// Calculates the axis aligned box that encapsulated the provided scene objects and their components and children. 
+        /// Only certain components like <see cref="Renderable"/> will be included in bound calculations.
+        /// </summary>
+        /// <param name="objects">Scene objects to calculate the bounds for.</param>
+        /// <returns>Axis aligned box encompassing all scene object elements, in world space.</returns>
         public static AABox CalculateBounds(SceneObject[] objects)
         {
             AABox bounds;
@@ -20,6 +35,12 @@ namespace BansheeEditor
             return bounds;
         }
 
+        /// <summary>
+        /// Converts a hierarchy of scene objects and their children into a flat array. Doesn't modify the scene object's
+        /// themselves. 
+        /// </summary>
+        /// <param name="so">Scene object whose hierarchy to flatten.</param>
+        /// <returns>Array of flattened hierarchy in a depth-first manner.</returns>
         public static SceneObject[] FlattenHierarchy(SceneObject so)
         {
             Stack<SceneObject> todo = new Stack<SceneObject>();

MBansheeEditor/Program.cs

@@ -4,15 +4,25 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Entry point to the editor.
+    /// </summary>
     class Program
     {
         private static EditorApplication app;
 
+        /// <summary>
+        /// Called by the runtime whenever the editor assembly is loaded. This means initially when editor is started
+        /// and every time assembly refresh occurs.
+        /// </summary>
         static void OnInitialize()
         {
             app = new EditorApplication();
         }
 
+        /// <summary>
+        /// Called by the runtime when the editor is first started. Called after <see cref="OnInitialize"/>.
+        /// </summary>
         static void OnEditorLoad()
         {
             if (EditorSettings.AutoLoadLastProject)
@@ -27,6 +37,9 @@ namespace BansheeEditor
                 ProjectWindow.Open();
         }
 
+        /// <summary>
+        /// Called 60 times per second by the runtime.
+        /// </summary>
         static void OnEditorUpdate()
         {
             app.OnEditorUpdate();

MBansheeEditor/ProjectSettings.cs

@@ -10,74 +10,143 @@ using BansheeEngine;
 
 namespace BansheeEditor
 {
+    /// <summary>
+    /// Contains various settings that are applied globally per project. Settings will persist through editor sessions.
+    /// </summary>
     internal static class ProjectSettings
     {
+        /// <summary>
+        /// Contains the path to the last open scene. Path is relative to the project's resources folder.
+        /// </summary>
         public static string LastOpenScene
         {
             get { return Internal_GetLastOpenScene(); }
             set { Internal_SetLastOpenScene(value); }
         }
 
+        /// <summary>
+        /// Contains a hash value that is updated whenever one of the properties in this object is updated. This allows
+        /// external systems to track when they might need to reload the settings.
+        /// </summary>
         public static int Hash
         {
             get { return Internal_GetHash(); }
         }
 
+        /// <summary>
+        /// Sets a generic floating point property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetFloat(string name, float value)
         {
             Internal_SetFloat(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic integer property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetInt(string name, int value)
         {
             Internal_SetInt(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic boolean property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetBool(string name, bool value)
         {
             Internal_SetBool(name, value);
         }
 
+        /// <summary>
+        /// Sets a generic string property.
+        /// </summary>
+        /// <param name="name">Name to record the property under.</param>
+        /// <param name="value">Value of the property.</param>
         public static void SetString(string name, String value)
         {
             Internal_SetString(name, value);
         }
 
+        /// <summary>
+        /// Retrieves a generic floating point property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static float GetFloat(string name, float defaultValue = 0.0f)
         {
             return Internal_GetFloat(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic integer property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static int GetInt(string name, int defaultValue = 0)
         {
             return Internal_GetInt(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic boolean property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static bool GetBool(string name, bool defaultValue = false)
         {
             return Internal_GetBool(name, defaultValue);
         }
 
+        /// <summary>
+        /// Retrieves a generic string property.
+        /// </summary>
+        /// <param name="name">Name of the property to retrieve.</param>
+        /// <param name="defaultValue">Default value to return if property cannot be found.</param>
+        /// <returns>Value of the property if it exists, otherwise the default value.</returns>
         public static String GetString(string name, string defaultValue = "")
         {
             return Internal_GetString(name, defaultValue);
         }
 
+        /// <summary>
+        /// Checks does a generic property with the specified name exists.
+        /// </summary>
+        /// <param name="name">Name of the property to check.</param>
+        /// <returns>True if the property exists, false otherwise.</returns>
         public static bool HasKey(string name)
         {
             return Internal_HasKey(name);
         }
 
+        /// <summary>
+        /// Deletes a generic property with the specified name.
+        /// </summary>
+        /// <param name="name">Name of the property to delete.</param>
         public static void DeleteKey(string name)
         {
             Internal_DeleteKey(name);
         }
 
+        /// <summary>
+        /// Deletes all generic properties.
+        /// </summary>
         public static void DeleteAllKeys()
         {
             Internal_DeleteAllKeys();
         }
 
+        /// <summary>
+        /// Saves project settings to the disk.
+        /// </summary>
         public static void Save()
         {
             Internal_Save();

MBansheeEditor/Scene/Handle.cs

@@ -12,8 +12,21 @@ namespace BansheeEditor
     {
         private List<HandleSlider> sliders = new List<HandleSlider>();
 
+        /// <summary>
+        /// Called every frame before handle input is processed. Allows handle transforms to be updated before input.
+        /// </summary>
         protected internal abstract void PreInput();
+
+        /// <summary>
+        /// Called every frame after handle input is processed. Active handle sliders should contain values signals if and
+        /// how much they were dragged.
+        /// </summary>
         protected internal abstract void PostInput();
+
+        /// <summary>
+        /// Called every frame after <see cref="PostInput"/>. Allows handles graphics to be drawn. This is the only
+        /// method that draw methods <see cref="Handles"/> may be called.
+        /// </summary>
         protected internal abstract void Draw();
 
         /// <summary>