Done basic documentation. Further expansion may be needed. Maybe. But only maybe.

RecrownedAthenaeum/DataTypes/TextureAtlas.cs

@@ -5,12 +5,27 @@ using System.Collections.Generic;
 
 namespace RecrownedAthenaeum.DataTypes
 {
+    /// <summary>
+    /// Holds information about an image file that contains various textures in various regions in the file.
+    /// </summary>
     public class TextureAtlas
     {
         private Texture2D texture;
 
         private Dictionary<string, TextureAtlasRegion> dictionaryOfRegions = new Dictionary<string, TextureAtlasRegion>();
+        
+        /// <summary>
+        /// Given a name, can return a <see cref="TextureAtlasRegion"/>.
+        /// </summary>
+        /// <param name="name">Name of <see cref="TextureAtlasRegion"/> to obtain.</param>
+        /// <returns><see cref="TextureAtlasRegion"/> based off name.</returns>
         public TextureAtlasRegion this[string name] { get { if (name != null && dictionaryOfRegions.ContainsKey(name)) return dictionaryOfRegions[name]; else return null; } }
+
+        /// <summary>
+        /// Creates a texture atlas with given main texture as well as an array of <see cref="TextureAtlasRegion"/> to represent locations of which textures reside within the atlas. Region names will be used to refer to the regions within the dictionary.
+        /// </summary>
+        /// <param name="texture">The texture representing the overall atlas.</param>
+        /// <param name="regions">The sub regions that represent the individual textures.</param>
         public TextureAtlas(Texture2D texture, TextureAtlasRegion[] regions)
         {
             this.texture = texture;
@@ -20,6 +35,11 @@ namespace RecrownedAthenaeum.DataTypes
             }
         }
 
+        /// <summary>
+        /// Creates a texture region given a dictionary of regions keyed to strings that can be used to refer to them.
+        /// </summary>
+        /// <param name="texture">The texture representing the overall atlas.</param>
+        /// <param name="dictionaryOfRegions"></param>
         public TextureAtlas(Texture2D texture, Dictionary<string, TextureAtlasRegion> dictionaryOfRegions)
         {
             this.texture = texture;
@@ -51,13 +71,23 @@ namespace RecrownedAthenaeum.DataTypes
             return dictionaryOfRegions[name].AsTexture2D(graphicsDevice);
         }
 
+        /// <summary>
+        /// A region of a <see cref="TextureAtlas"/>.
+        /// </summary>
         public class TextureAtlasRegion : IComparable<TextureAtlasRegion>, ISpecialDrawable, IDisposable
         {
+            /// <summary>
+            /// The name of the region. Mostly used to be refered to within the context of a <see cref="TextureAtlas"/>.
+            /// </summary>
             public readonly string name;
+            /// <summary>
+            /// The location and dimensions of where the original texture resides on the texture representing the atlas.
+            /// </summary>
             public readonly Rectangle sourceRectangle;
             readonly NinePatch ninepatch;
             Texture2D atlasTexture;
             Texture2D regionTexture;
+            private bool disposed;
 
             /// <summary>
             /// A specified region in a texture atlas.
@@ -74,8 +104,18 @@ namespace RecrownedAthenaeum.DataTypes
                 this.ninepatch = ninePatch;
             }
 
-            public void Draw(SpriteBatch batch, Rectangle destination, Color color, float rotation, Vector2 origin)
+            /// <summary>
+            /// Draws the region. If ninepatch, rotation and origin are ignored.
+            /// </summary>
+            /// <param name="batch">The batch to use. Should be began.</param>
+            /// <param name="destination">The destination rectangle to draw to.</param>
+            /// <param name="color">The color to use.</param>
+            /// <param name="rotation">Rotation of the final drawing. Ignored if is a 9patch.</param>
+            /// <param name="origin">The origin of the drawing. Ignored if is a 9patch.</param>
+            public void Draw(SpriteBatch batch, Rectangle destination, Color color, float rotation = 0, Vector2 origin = default(Vector2))
             {
+                if (disposed) throw new ObjectDisposedException(GetType().Name);
+
                 if (ninepatch != null)
                 {
                     ninepatch.Draw(batch, destination);
@@ -92,6 +132,8 @@ namespace RecrownedAthenaeum.DataTypes
             /// <returns>The texture of the region.</returns>
             public Texture2D AsTexture2D(GraphicsDevice graphicsDevice)
             {
+                if (disposed) throw new ObjectDisposedException(GetType().Name);
+
                 if (regionTexture == null)
                 {
                     Color[] data = new Color[sourceRectangle.Width * sourceRectangle.Height];
@@ -102,14 +144,45 @@ namespace RecrownedAthenaeum.DataTypes
                 return regionTexture;
             }
 
+            /// <summary>
+            /// Compares this region to another in terms of name.
+            /// </summary>
+            /// <param name="other">The other region to compare to in terms of name.</param>
+            /// <returns>Less than one if precedes, greater than one if after, 0 if same.</returns>
             public int CompareTo(TextureAtlasRegion other)
             {
                 return name.CompareTo(other);
             }
 
+            /// <summary>
+            /// Call this to dispose.
+            /// </summary>
             public void Dispose()
             {
-                regionTexture?.Dispose();
+                if (disposed) throw new ObjectDisposedException(GetType().Name);
+                Dispose(true);
+                GC.SuppressFinalize(this);
+            }
+
+            /// <summary>
+            /// Overridable dispose.
+            /// </summary>
+            /// <param name="disposing">Whether or not this was a user made call.</param>
+            public virtual void Dispose(bool disposing)
+            {
+                if (disposing && !disposed)
+                {
+                    regionTexture?.Dispose();
+                }
+                disposed = true;
+            }
+            
+            /// <summary>
+            /// Destructor.
+            /// </summary>
+            ~TextureAtlasRegion()
+            {
+                Dispose(false);
             }
         }
     }