Commits

André Schnabel  committed 983bff9

Removed XML comments for methods to optimize signal/noise ratio.

  • Participants
  • Parent commits ea948ba

Comments (0)

Files changed (42)

File Audio/Song.cs

 		}
 		#endregion
 
-		/// <summary>
-		/// Play this song with optional looping.
-		/// </summary>
-		/// <param name="doLoop">True iff. this song should be looped to infinity.</param>
 		public void Play(bool doLoop = false) {
 			if(Globals.NoMusic || (doLoop && (clip.IsPlaying || loopThread != null))) return;
 
 			}
 		}
 
-		/// <summary>
-		/// Stop playback of this song.
-		/// </summary>
 		public void Stop() {
 			if(Globals.NoMusic) return;
 
 		public static void StopAllSongs() {}
 		private static Sound lastClip;
 
-		/// <summary>
-		/// Resume playback of last song.
-		/// </summary>
 		public static void ResumeSong() {
 			if(lastClip != null)
 				lastClip.Play();

File Audio/Sound.cs

 			}
 		}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Sound"/> class.
-		/// </summary>
 		public Sound(string path) {
 			if(Globals.NoSound) return;
 
 		}
 		#endregion
 
-		/// <summary>
-		/// Play this instance of this sound.
-		/// </summary>
 		public void Play() {
 			if(Globals.NoSound) return;
 
 			CheckAlError();
 		}
 
-		/// <summary>
-		/// True if an instance of this sound is currently playing.
-		/// </summary>
 		public bool IsPlaying {
 			get { 
 				if(Globals.NoSound) return false;
 			}
 		}
 
-		/// <summary>
-		/// Stop all instances of this sound.
-		/// </summary>
 		public void Stop() {
 			if(Globals.NoSound) return;
 
 	/// Sound helper.
 	/// </summary>
 	internal static class SoundHelper {
-		/// <summary>
-		/// Gets the sound format.
-		/// </summary>
-		/// <returns>
-		/// The sound format.
-		/// </returns>
-		/// <param name='channels'>
-		/// Channels.
-		/// </param>
-		/// <param name='bits'>
-		/// Bits.
-		/// </param>
 		public static ALFormat GetSoundFormat(int channels, int bits) {
 			switch(channels) {
 				case 1:
 			}
 		}
 
-		/// <summary>
-		/// Loads the wave.
-		/// </summary>
-		/// <returns>
-		/// The wave.
-		/// </returns>
-		/// <param name='stream'>
-		/// Stream.
-		/// </param>
-		/// <param name='channels'>
-		/// Channels.
-		/// </param>
-		/// <param name='bits'>
-		/// Bits.
-		/// </param>
-		/// <param name='rate'>
-		/// Rate.
-		/// </param>
 		public static byte[] LoadWave(Stream stream, out int channels, out int bits, out int rate) {
 			if(stream == null)
 				throw new ArgumentNullException("stream");

File Cameras/Camera.cs

 		protected Matrix4 ProjMx;
 		protected Matrix4 ViewMx;
 
-		/// <summary>
-		/// Constructs a new camera object with given matrices.
-		/// </summary>
-		/// <param name="projMx">Projection matrix.</param>
-		/// <param name="viewMx">Model-View matrix.</param>
 		public Camera(Matrix4 projMx, Matrix4 viewMx) {
 			ProjMx = projMx;
 			ViewMx = viewMx;
 		}
 
-		/// <summary>
-		/// Apply projection and transformation matrices of this camera.
-		/// Vertices in subsequent drawing calls get transformed and projected by the corresponding
-		/// matrices of this camera.
-		/// </summary>
 		public void Apply() {
 			GL.MatrixMode(MatrixMode.Projection);
 			GL.LoadMatrix(ref ProjMx.M11);
 		}
 
 		#region Accessors
-		/// <summary>
-		/// Quite likely either orthographic or perspective projection matrix.
-		/// </summary>
 		public Matrix4 ProjectionMatrix {
 			get { return ProjMx; }
 		}
-		/// <summary>
-		/// Transformation matrix. Translates, scales and rotates vertices multiplied with it.
-		/// </summary>
+
 		public Matrix4 ModelviewMatrix {
 			get { return ViewMx; }
 		}
 
-		/// <summary>
-		/// Model-view-projection combined matrix.
-		/// </summary>
 		public Matrix4 CombinedMatrix {
 			get { return ProjMx*ViewMx; }
 		}

File FpsCounter.cs

 		private long lastFpsDisplay;
 		private long frameCount;
 
-		/// <summary>
-		/// Should be called each frame.
-		/// </summary>
 		public void Tick() {
 			if(Utils.GetTicks() - lastFpsDisplay >= 1000) {
 				Utils.D("FPS=" + frameCount);
 	/// Global state. Design faux pas. :3
 	/// </summary>
 	public class Globals {
-		/// <summary>True iff. sound playback should be deactivated.</summary>
 		public static bool NoSound;
-		/// <summary>True iff. music playback should be deactivated.</summary>
 		public static bool NoMusic;
 
-		/// <summary>Current platform. Either Android, Desktop or IPhone.</summary>
 		public static AbstractPlatform Platform;
 
 #if IOS || ANDROID || WINDOWS_PHONE
 		public const bool PhoneMode = true;
 #else
 		// Desktop
-		/// <summary> Current screen width in pixels.</summary>
 		public static int ScrW = 800;
-		/// <summary>Current screen height in pixels.</summary>
 		public static int ScrH = 480;
-		/// <summary>Used for debugging phone code path on desktop.</summary>
 		public const bool PhoneMode = false;
 #endif
-		/// <summary>(float)ScrW/ScrH</summary>
 		public static float AspectRatio;
 	}
 }

File IStateManager.cs

 	/// and can be used for state transitions.
 	/// </summary>
 	public interface IStateManager {
-		/// <summary>
-		/// Sets the new current state. Disposes old state.
-		/// </summary>
-		/// <param name='s'>
-		/// New current state.
-		/// </param>
 		void SetState(State s);
 	}
 }
 	/// Caption and screen dimensions only used for desktop applications.
 	/// </summary>
 	public struct GameConfiguration {
-		/// <summary>
-		/// Callback that can be called by the launcher after initializing Kosu.
-		/// </summary>
-		/// <param name="stateMgr">State manager passed to the newly created state.</param>
-		/// <returns>Initialized instance of the initial state of a game.</returns>
 		public delegate State InitialStateFactoryDelegate(IStateManager stateMgr);
 
-		#region Desktop application parameters
-		/// <summary>
-		/// The caption used for the window title in desktop applications.
-		/// </summary>
 		public String Caption;
-		/// <summary>
-		/// Screen dimensions (width and height).
-		/// </summary>
 		public int ScrW, ScrH;
-		#endregion
 
-		#region Initial state creation
-		/// <summary>
-		/// The type of the initial game state. The constructor with IStateManager as parameter of this state
-		/// is only called when enough systems are setup.
-		/// </summary>
 		public Type InitialStateType;
-		/// <summary>
-		/// Optional method creating an instance of state for the initial state. Useful for better exception handling
-		/// than when initializing state through Type and reflection.
-		/// </summary>
 		public InitialStateFactoryDelegate InitialStateFactory;
-		#endregion
 
-		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.GameConfiguration"/> struct.
-		/// </summary>
-		/// <param name='caption'>Window title. Only used in desktop apps.</param>
-		/// <param name='scrW'>Screen width. Only used in desktop apps.</param>
-		/// <param name='scrH'>Screen height. Only used in desktop apps.</param>
-		/// <param name='initialStateType'>Type of the initial game state.</param>
-		/// <param name='initialStateFactory'>Method creating instance of state for initial state.</param>
 		public GameConfiguration(string caption, int scrW, int scrH, Type initialStateType, InitialStateFactoryDelegate initialStateFactory = null) {
 			Caption = caption;
 			ScrW = scrW;
 			InitialStateType = initialStateType;
 			InitialStateFactory = initialStateFactory;
 		}
-		#endregion
 	}
 
 #if !MOBILE
 	/// Launcher used in desktop applications.
 	/// </summary>
 	public class Launcher {
-		/// <summary>
-		/// Launch the game with specified args and game configuration.
-		/// </summary>
-		/// <param name='args'>Application command line parameters.</param>
-		/// <param name='configuration'>Game configuration specifiying game specific options.</param>
 		public static void Launch(string[] args, GameConfiguration configuration) {
 			bool fullscreen = false;
 

File Math/BoundingBox.cs

 	/// Bounding box used for frustum culling objects.
 	/// </summary>
 	public class BoundingBox {
-		/// <summary>
-		/// Edge point with maximum coordinate values.
-		/// </summary>
 		public Vector3 Max;
-		/// <summary>
-		/// Edge point with minimum coordinate values.
-		/// </summary>
 		public Vector3 Min;
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="BoundingBox"/> class.
-		/// </summary>
-		/// <param name='minX'>
-		/// Min x.
-		/// </param>
-		/// <param name='maxX'>
-		/// Max x.
-		/// </param>
-		/// <param name='minY'>
-		/// Minimum y.
-		/// </param>
-		/// <param name='maxY'>
-		/// Max y.
-		/// </param>
-		/// <param name='minZ'>
-		/// Minimum z.
-		/// </param>
-		/// <param name='maxZ'>
-		/// Max z.
-		/// </param>
 		public BoundingBox(float minX, float maxX, float minY, float maxY, float minZ, float maxZ) {
 			Min.X = minX;
 			Min.Y = minY;
 			Max.Z = maxZ;
 		}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="BoundingBox"/> class.
-		/// </summary>
-		/// <param name='min'>
-		/// Minimum edge point.
-		/// </param>
-		/// <param name='max'>
-		/// Max edge point.
-		/// </param>
 		public BoundingBox(Vector3 min, Vector3 max) {
 			Min = min;
 			Max = max;

File Math/Frustum.cs

 		private readonly Vector3[] points = new Vector3[8];
 		private readonly Camera cam;
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Math.Frustum"/> class.
-		/// </summary>
-		/// <param name='cam'>
-		/// Camera inducing the view frustum.
-		/// </param>
 		public Frustum(Camera cam) {
 			this.cam = cam;
 		}
 
-		/// <summary>
-		/// Updates the frustum to the transformation and projection of the camera.
-		/// </summary>
 		public void Update() {
 #if NO_FRUSTUM
 			return;
 			return (plane.X*p.X + plane.Y*p.Y + plane.Z*p.Z + plane.W) <= 0;
 		}
 
-		/// <summary>
-		/// Box inside frustum.
-		/// </summary>
-		/// <returns>
-		/// True iff. the box is inside the frustum.
-		/// </returns>
-		/// <param name='bbox'>
-		/// Bounding box to be checked for frustum culling.
-		/// </param>
 		public bool BoxInFrustum(BoundingBox bbox) {
 #if NO_FRUSTUM
 			return true;

File Math/Intersector.cs

 	/// A ray. That is an infinite line originating from one point hence being finite in exactly one direction.
 	/// </summary>
 	public struct Ray {
-		/// <summary>
-		/// The direction of the ray.
-		/// </summary>
 		public Vector3 Direction;
-		/// <summary>
-		/// The originating position of the ray.
-		/// </summary>
 		public Vector3 Position;
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Math.Ray"/> struct.
-		/// </summary>
-		/// <param name='position'>
-		/// The originating potion of the ray.
-		/// </param>
-		/// <param name='direction'>
-		/// Direction of the ray.
-		/// </param>
 		public Ray(Vector3 position, Vector3 direction) {
 			Debug.Assert(direction.LengthSquared - 1.0f < 0.00001f, "Ray direction must be normalized!");
 			Position = position;
 		private static Vector3 candidate, inPos;
 		private static Vector3 t1, t2, t3;
 
-		/// <summary>
-		/// Calculate intersection point (if any, see return value) of a given ray with a
-		/// given list of triangle vertex arrays.
-		/// </summary>
-		/// <returns>
-		/// If there is any point of intersection.
-		/// </returns>
-		/// <param name='ray'>
-		/// The ray.
-		/// </param>
-		/// <param name='triArrays'>
-		/// The list of arrays of vertices of triangles.
-		/// </param>
-		/// <param name='isect'>
-		/// The intersection point (if any, see return value) is written into this reference.
-		/// </param>
 		public static bool IntersectRayTriangles(Ray ray, IList<float[]> triArrays, ref Vector3 isect) {
 			float minDist = float.MaxValue;
 
 			return false;
 		}
 
-		/// <summary>
-		/// Calculates the intersection point (if any, see return value) of a given ray
-		/// with a given set of triangles defined by an array of their vertices. Hence
-		/// tris.Length should be divisable by 3.
-		/// </summary>
-		/// <returns>
-		/// True iff. the ray intersects a triangle defined by the given triangle vertices.
-		/// </returns>
-		/// <param name='ray'>
-		/// Ray used for intersection.
-		/// </param>
-		/// <param name='tris'>
-		/// An array of vertices of triangles.
-		/// </param>
-		/// <param name='isect'>
-		/// This reference is set to the position of the intersection of this ray with
-		/// a given set of triangles. If any. See return value.
-		/// </param>
 		public static bool IntersectRayTriangles(Ray ray, float[] tris, ref Vector3 isect) {
 			float minDist = float.MaxValue;
 

File Math/Matrix4.cs

 	[Serializable]
 	[StructLayout(LayoutKind.Sequential)]
 	public struct Matrix4 {
-		// Stored column major
 
-		#region Matrix elements
 		// First column
 		public float M11;
 		public float M21;
 		public float M24;
 		public float M34;
 		public float M44;
-		#endregion
 
-		#region Columns
 		public Vector4 Column1 {
 			get { return new Vector4(M11, M21, M31, M41); }
 		}
 		public Vector4 Column4 {
 			get { return new Vector4(M14, M24, M34, M44); }
 		}
-		#endregion
 
-		#region Rows
 		public Vector4 Row1 {
 			get { return new Vector4(M11, M12, M13, M14); }
 		}
 		public Vector4 Row4 {
 			get { return new Vector4(M41, M42, M43, M44); }
 		}
-		#endregion
 
-		/// <summary>Identity matrix. Multiplying with it returns other factor.</summary>
-		public static Matrix4 Identity = new Matrix4(1, 0, 0, 0, // 1st
-		                                             0, 1, 0, 0, // 2nd
-		                                             0, 0, 1, 0, // 3rd
-		                                             0, 0, 0, 1); // 4th
+		public static Matrix4 Identity = new Matrix4(1, 0, 0, 0,
+		                                             0, 1, 0, 0,
+		                                             0, 0, 1, 0,
+		                                             0, 0, 0, 1);
 
-		#region Constructors
-		/// <summary>
-		/// Construct a new matrix with given elements.
-		/// </summary>
-		/// <param name="a11"></param>
-		/// <param name="a12"></param>
-		/// <param name="a13"></param>
-		/// <param name="a14"></param>
-		/// <param name="a21"></param>
-		/// <param name="a22"></param>
-		/// <param name="a23"></param>
-		/// <param name="a24"></param>
-		/// <param name="a31"></param>
-		/// <param name="a32"></param>
-		/// <param name="a33"></param>
-		/// <param name="a34"></param>
-		/// <param name="a41"></param>
-		/// <param name="a42"></param>
-		/// <param name="a43"></param>
-		/// <param name="a44"></param>
 		public Matrix4(float a11, float a12, float a13, float a14, // 1st row
 		               float a21, float a22, float a23, float a24, // 2nd row 
 		               float a31, float a32, float a33, float a34, // 3rd row
 			M34 = a34;
 			M44 = a44;
 		}
-		#endregion
 
 		#region Matrix arithmetics
-		/// <summary>
-		/// Add two matrices and return resulting sum matrix.
-		/// </summary>
-		/// <param name="a">First summand.</param>
-		/// <param name="b">Second summand.</param>
-		/// <returns>Sum matrix.</returns>
 		public static Matrix4 operator +(Matrix4 a, Matrix4 b) {
 			a.M11 += b.M11;
 			a.M21 += b.M21;
 			return a;
 		}
 
-		/// <summary>
-		/// Substract matrix b from matrix a and return resulting delta.
-		/// </summary>
-		/// <param name="a">Minuend matrix.</param>
-		/// <param name="b">Subtrahend matrix.</param>
-		/// <returns>Delta matrix.</returns>
 		public static Matrix4 operator -(Matrix4 a, Matrix4 b) {
 			a.M11 -= b.M11;
 			a.M21 -= b.M21;
 			return a;
 		}
 
-		/// <summary>
-		/// Matrix multiply two matrices.
-		/// </summary>
-		/// <param name="a">First factor.</param>
-		/// <param name="b">Second factor.</param>
-		/// <returns>Resulting product matrix.</returns>
 		public static Matrix4 operator *(Matrix4 a, Matrix4 b) {
 			var c = new Matrix4();
 			c.M11 = a.M11*b.M11 + a.M12*b.M21 + a.M13*b.M31 + a.M14*b.M41;
 			return c;
 		}
 
-		/// <summary>Multiply a matrix with a 3d vector.</summary>
-		/// <param name="a">Matrix A.</param>
-		/// <param name="v">Vector V.</param>
-		/// <returns>Vector resulting from this product.</returns>
 		public static Vector3 operator *(Matrix4 a, Vector3 v) {
 			return new Vector3(a.M11*v.X + a.M12*v.Y + a.M13*v.Z, // x
 			                   a.M21*v.X + a.M22*v.Y + a.M23*v.Z, // y
 			                   a.M31*v.X + a.M32*v.Y + a.M33*v.Z); // z
 		}
 
-		/// <summary>Multiply a matrix with a 4d vector.</summary>
-		/// <param name="a">Matrix A.</param>
-		/// <param name="v">Vector V.</param>
-		/// <returns>Vector resulting from this product.</returns>
 		public static Vector4 operator *(Matrix4 a, Vector4 v) {
 			return new Vector4(a.M11*v.X + a.M12*v.Y + a.M13*v.Z + a.M14*v.W, // x
 			                   a.M21*v.X + a.M22*v.Y + a.M23*v.Z + a.M24*v.W, // y
 			                   a.M41*v.X + a.M42*v.Y + a.M43*v.Z + a.M44*v.W); // w
 		}
 
-		/// <summary>Invert the current matrix.</summary>
-		/// <returns>True iff. this matrix can be inverted.</returns>
 		public bool Invert() {
 			var inv = new float[16];
 
 			return true;
 		}
 
-		/// <summary>Invert all elements to their negative counterparts.</summary>
-		/// <param name="a">Matrix that should be multiplied with -1.</param>
-		/// <returns>-1 multiplication product of Matrix.</returns>
 		public static Matrix4 operator -(Matrix4 a) {
 			return new Matrix4(-a.M11, -a.M12, -a.M13, -a.M14, // 1st
 			                   -a.M21, -a.M22, -a.M23, -a.M24, // 2nd
 			                   -a.M41, -a.M42, -a.M43, -a.M44); // 4th
 		}
 
-		/// <summary>
-		/// Multiply a matrix with a given scalar constant.
-		/// </summary>
-		/// <param name="a">Matrix that should be multiplied with k.</param>
-		/// <param name="k">Constant used for multiplication.</param>
-		/// <returns>Resulting matrix with each element multiplied by k.</returns>
 		public static Matrix4 operator *(Matrix4 a, float k) {
 			return new Matrix4(a.M11*k, a.M12*k, a.M13*k, a.M14*k, // 1st
 			                   a.M21*k, a.M22*k, a.M23*k, a.M24*k, // 2nd
 		#endregion
 
 		#region Calculate matrices from parameters
-		/// <summary>
-		/// Create orthographic projection matrix.
-		/// </summary>
-		/// <param name="left"></param>
-		/// <param name="right"></param>
-		/// <param name="bottom"></param>
-		/// <param name="top"></param>
-		/// <param name="near"></param>
-		/// <param name="far"></param>
-		/// <returns></returns>
 		public static Matrix4 CreateOrthoProjection(float left, float right, float bottom, float top, float near, float far) {
 			var pmx = new Matrix4();
 			pmx.M11 = 2.0f/(right - left);
 			return pmx;
 		}
 
-		/// <summary>
-		/// Create perspective projection matrix.
-		/// </summary>
-		/// <param name="fovRad"></param>
-		/// <param name="aspect"></param>
-		/// <param name="near"></param>
-		/// <param name="far"></param>
-		/// <returns></returns>
 		public static Matrix4 CreatePerspectiveProjection(float fovRad, float aspect, float near, float far) {
 			float f = 1.0f/(float) System.Math.Tan(fovRad/2.0f);
 			var pmx = new Matrix4();
 			return pmx;
 		}
 
-		/// <summary>
-		/// Create rotation matrix. Multiply a vector with this to rotate it.
-		/// </summary>
-		/// <param name="axis">Axis of rotation.</param>
-		/// <param name="alpha">Angle of rotation in radians.</param>
-		/// <returns></returns>
 		public static Matrix4 CreateRotationMatrix(Vector3 axis, float alpha) {
 			var rmx = new Matrix4();
 			float x = axis.X;
 		}
 		#endregion
 
-		#region Formatting methods
-		/// <summary>Return string representation of this matrix.</summary>
-		/// <returns>String representation of this matrix.</returns>
 		public override string ToString() {
 			return string.Format("{0}|{1}|{2}|{3}", Row1, Row2, Row3, Row4);
 		}
-		#endregion
 
 		#region Transposition
-		/// <summary>Return a transposed copy of this matrix.</summary>
-		/// <returns>Transposed copy of this matrix.</returns>
 		public Matrix4 TransposedCopy() {
 			Matrix4 copy = this;
 			copy.M21 = M12;
 			return copy;
 		}
 
-		/// <summary>Transpose this matrix.</summary>
 		public void Transpose() {
 			this = TransposedCopy();
 		}

File Math/Noise.cs

 	/// Static methods to calculate perlin noise.
 	/// </summary>
 	public static class Noise {
-		/// <summary>
-		/// Calculate perlin noise.
-		/// </summary>
-		/// <returns>
-		/// Noise value.
-		/// </returns>
-		/// <param name='x'>
-		/// Argument X.
-		/// </param>
-		/// <param name='y'>
-		/// Argument Y.
-		/// </param>
-		/// <param name='rval'>
-		/// Argument Rval.
-		/// </param>
 		public static float CalcNoise(float x, float y, int rval) {
 			float floorX = ((int) x), floorY = ((int) y);
 

File Math/Vector2.cs

 	[Serializable]
 	[StructLayout(LayoutKind.Sequential)]
 	public struct Vector2 {
-		#region Coordinates
 		public float X;
 		public float Y;
-		#endregion
 
 		public static Vector2 Zero = new Vector2(0, 0);
 		public static Vector2 UnitX = new Vector2(1, 0);
 		public static Vector2 UnitY = new Vector2(0, 1);
 		public static Vector2 Unit = new Vector2(1, 1);
 
-		#region Constructors
-		/// <summary>
-		/// Construct a new vector with given coordinates.
-		/// </summary>
-		/// <param name="x">x-Coordinate</param>
-		/// <param name="y">y-Coordinate</param>
 		public Vector2(float x, float y) {
 			X = x;
 			Y = y;
 		}
-		#endregion
 
-		#region Vector arithmetics
-		/// <summary>
-		/// Adds two vectors and returns the sum.
-		/// </summary>
-		/// <param name="a"></param>
-		/// <param name="b"></param>
-		/// <returns></returns>
 		public static Vector2 operator +(Vector2 a, Vector2 b) {
 			a.X += b.X;
 			a.Y += b.Y;
 			return a;
 		}
 
-		/// <summary>
-		/// Substracts vector b from vector a and returns the delta vector.
-		/// </summary>
-		/// <param name="a"></param>
-		/// <param name="b"></param>
-		/// <returns></returns>
 		public static Vector2 operator -(Vector2 a, Vector2 b) {
 			a.X -= b.X;
 			a.Y -= b.Y;
 		public static Vector2 operator *(Vector2 v, float c) {
 			return new Vector2(v.X*c, v.Y*c);
 		}
-		#endregion
 
 		#region Equality methods
 		public bool Equals(Vector2 other) {
 		}
 		#endregion
 
-		/// <summary>
-		/// Normalize this vector. That is changing its magnitude to 1 while keeping its direction.
-		/// </summary>
 		public void Normalize() {
 			float c = 1.0f/Length;
 			X *= c;
 			return cpy;
 		}
 
-		/// <summary>
-		/// Euclidean magnitude or length of this vector.
-		/// </summary>
 		public float Length {
 			get { return (float) System.Math.Sqrt(X*X + Y*Y); }
 		}
 
-		/// <summary>
-		/// Rotate 2D vector around Z-axis
-		/// </summary>
-		/// <param name="alpha">rotation angle in radians</param>
-		/// <returns>Rotated vector</returns>
 		public Vector2 RotateZ(float alpha) {
 			var sinAlpha = (float) System.Math.Sin(alpha);
 			var cosAlpha = (float) System.Math.Cos(alpha);

File Math/Vector3.cs

 	[Serializable]
 	[StructLayout(LayoutKind.Sequential)]
 	public struct Vector3 {
-		#region Coordinates
 		public float X;
 		public float Y;
 		public float Z;
-		#endregion
 
 		public static Vector3 Zero = new Vector3(0, 0, 0);
 		public static Vector3 UnitX = new Vector3(1, 0, 0);
 		public static Vector3 UnitZ = new Vector3(0, 0, 1);
 		public static Vector3 Unit = new Vector3(1, 1, 1);
 
-		#region Constructors
-		/// <summary>
-		/// Initialize three dimensional vector with given coordinates.
-		/// </summary>
-		/// <param name="x">x-Axis coordinate.</param>
-		/// <param name="y">y-Axis coordinate.</param>
-		/// <param name="z">z-Axis coordiante.</param>
 		public Vector3(float x, float y, float z) {
 			X = x;
 			Y = y;
 			Z = z;
 		}
-		#endregion
 
-		#region Vector arithmetics
-		/// <summary>Add two vectors.</summary>
-		/// <param name="a">First summand.</param>
-		/// <param name="b">Second summand.</param>
-		/// <returns>Vector sum of a and b.</returns>
 		public static Vector3 operator +(Vector3 a, Vector3 b) {
 			a.X += b.X;
 			a.Y += b.Y;
 			return a;
 		}
 
-		/// <summary>Substract vector b from vector a.</summary>
-		/// <param name="a">Minuend.</param>
-		/// <param name="b">Subtrahend.</param>
-		/// <returns>Vector difference of a and b. This is equal to the displacement vector from b to a.</returns>
+
 		public static Vector3 operator -(Vector3 a, Vector3 b) {
 			a.X -= b.X;
 			a.Y -= b.Y;
 			return a;
 		}
 
-		/// <summary>Calculate negative of a vector. That is a vector with same magnitude but opposite direction.</summary>
-		/// <param name="a">Vector.</param>
-		/// <returns>Negative of given vector.</returns>
+
 		public static Vector3 operator -(Vector3 a) {
 			return new Vector3(-a.X, -a.Y, -a.Z);
 		}
 
-		/// <summary>Calculate the scalar product (dot-product) of two 3d vectors. <seealso cref="Vector3.Dot"/></summary>
-		/// <param name="a">First factor.</param>
-		/// <param name="b">Second factor.</param>
-		/// <returns>Scalar product (dot-product) of a and b. That is magnitude of a and b multiplied times the cosine of the angle between them.</returns>
 		public static float operator *(Vector3 a, Vector3 b) {
 			return a.X*b.X + a.Y*b.Y + a.Z*b.Z;
 		}
 
-		/// <summary>Multiply a given vector v by a given constant k.</summary>
-		/// <param name="v">3d vector.</param>
-		/// <param name="k">Single precision floating point scalar constant.</param>
-		/// <returns>Vector with scalar multiplication product of v and k.</returns>
 		public static Vector3 operator *(Vector3 v, float k) {
 			return new Vector3(v.X*k, v.Y*k, v.Z*k);
 		}
 
-		/// <summary>Calculate the scalar product (dot-product) of two 3d vectors.</summary>
-		/// <param name="a">First factor.</param>
-		/// <param name="b">Second factor.</param>
-		/// <returns>Scalar product (dot-product) of a and b. That is magnitude of |a| and |b| multiplied times the cosine of the angle between them.</returns>
 		public static float Dot(Vector3 a, Vector3 b) {
 			return a.X*b.X + a.Y*b.Y + a.Z*b.Z;
 		}
 
-		/// <summary>
-		/// Calculate the cross product of two 3d vectors.
-		/// </summary>
-		/// <param name="a">First factor.</param>
-		/// <param name="b">Second factor.</param>
-		/// <returns>Cross product of a and b. That is a vector orthogonal on a and b with magnitude of |a| and |b| multiplied times the sine of the angle between them.</returns>
 		public static Vector3 Cross(Vector3 a, Vector3 b) {
 			return new Vector3(a.Y*b.Z - a.Z*b.Y, a.Z*b.X - a.X*b.Z, a.X*b.Y - a.Y*b.X);
 		}
-		#endregion
 
 		#region Equality methods
 		public bool Equals(Vector3 other) {
 		}
 		#endregion
 
-		/// <summary>Normalize this vector. That is keeping direction while changing the magnitude to 1. In-place operation.</summary>
 		public void Normalize() {
 			float c = 1.0f/Length;
 			X *= c;
 			Z *= c;
 		}
 
-		/// <summary>Calculate a normalized copy of this vector. See also: <seealso cref="Vector3.Normalize"/>.</summary>
-		/// <returns>A vector with same direction as this vector but magnitude of 1.</returns>
 		public Vector3 NormalizedCopy() {
 			Vector3 cpy = this;
 			cpy.Normalize();
 			return cpy;
 		}
 
-		/// <summary>Calculate the euclidean length of this vector.</summary>
 		public float Length {
 			get { return (float) System.Math.Sqrt(X*X + Y*Y + Z*Z); }
 		}
 			get { return X*X + Y*Y + Z*Z; }
 		}
 
-		/// <summary>
-		/// Rot the vector around the given axis with angle alpha (in radians, ccw).
-		/// </summary>
-		/// <param name='axis'>
-		/// The rotation axis.
-		/// </param>
-		/// <param name='alpha'>
-		/// The rotation angle alpha in radians for counter clockwise (ccw) rotation.
-		/// </param>
 		public Vector3 Rot(Vector3 axis, float alpha) {
 			return Matrix4.CreateRotationMatrix(axis, alpha)*this;
 		}
 
-		/// <summary>
-		/// Calculate the angle (in radians) between a vector and another normalized given vector.
-		/// </summary>
-		/// <returns>
-		/// Angle in radians (ccw) between this and another normalized vector.
-		/// </returns>
-		/// <param name='normalized'>
-		/// A normalized vector.
-		/// </param>
 		public float AngleBetweenNor(Vector3 normalized) {
 			float l = Length;
 			if(l == 0) {
 			return (float) System.Math.Acos((this*other)/(l1*l2));
 		}
 
-		#region Formatting methods
 		public override string ToString() {
 			return string.Format("{0};{1};{2}", X, Y, Z);
 		}
-		#endregion
 	}
 }

File Math/Vector4.cs

 		}
 		#endregion
 
-		/// <summary>
-		/// Normalize this vector. That is changing its magnitude to 1 while keeping its direction.
-		/// </summary>
 		public void Normalize() {
 			float c = 1.0f/Length;
 			X *= c;
 			W *= c;
 		}
 
-		/// <summary>
-		/// Euclidiean magnitude or length of this vector.
-		/// </summary>
 		public float Length {
 			get { return (float) System.Math.Sqrt(X*X + Y*Y + Z*Z); }
 		}
 
-		/// <summary>
-		/// Transform a vector with given matrix.
-		/// </summary>
-		/// <param name="v"></param>
-		/// <param name="m"></param>
-		/// <returns></returns>
 		public static Vector4 Transform(Vector4 v, Matrix4 m) {
 			return m*v;
 		}

File MouseBtns.cs

 	/// This is only a passive data container filled by other classes.
 	/// </summary>
 	public struct MouseBtns {
-		#region Fields
-		/// <summary>
-		/// Left mouse button pressed.
-		/// </summary>
+
 		public bool Lmb;
-		/// <summary>
-		/// Middle mouse button pressed.
-		/// </summary>
 		public bool Mmb;
-		/// <summary>
-		/// Right mouse button pressed.
-		/// </summary>
 		public bool Rmb;
-		#endregion
 
-		#region Constructors
-		/// <summary>
-		/// Creates new object representing mouse button state.
-		/// </summary>
 		public MouseBtns(bool lmb = false, bool mmb = false, bool rmb = false) {
 			Lmb = lmb;
 			Mmb = mmb;
 			Rmb = rmb;
 		}
-		#endregion
 
-		/// <summary>
-		/// No button at all is pressed.
-		/// </summary>
-		/// <returns>True iff. all mouse buttons are released.</returns>
 		public bool NonePressed() {
 			return !(Lmb || Mmb || Rmb);
 		}
 
-		/// <summary>
-		/// Reset all buttons.
-		/// </summary>
 		public void Clear() {
 			Lmb = Mmb = Rmb = false;
 		}

File Observable.cs

 	public abstract class Observable<T> {
 		private readonly IList<IObserver<T>> observers = new List<IObserver<T>>();
 
-		/// <summary>
-		/// Adds another observer that gets notified of changes.
-		/// </summary>
-		/// <param name='o'>
-		/// Observer implementing IObserver-interface for the correct type T.
-		/// </param>
 		public void AddObserver(IObserver<T> o) {
 			observers.Add(o);
 		}
 
-		/// <summary>
-		/// Notifies registered observers.
-		/// </summary>
-		/// <param name='changed'>
-		/// Object that has changed.
-		/// </param>
 		public void NotifyObservers(T changed) {
 			foreach(var o in observers) {
 				o.Update(changed);

File Platforms/AbstractPlatform.cs

 	/// </summary>
 	public abstract class AbstractPlatform {
 		// TODO: Let this return a Kosu.Rendering.Texture for more OpenTK independence.
-		/// <summary>Load an OpenGL texture from given filename.</summary>
-		/// <param name="filename">Path of raster graphics image relative to the data folder.</param>
-		/// <param name="nearestFiltering">True iff. nearest filtering should be used to render this texture. Linear filtering is used iff. false.</param>
-		/// <returns>OpenGL texture handle.</returns>
 		public abstract uint LoadTexture(string filename, bool nearestFiltering);
 
-		/// <summary>Determine the raster graphics image dimensions.</summary>
-		/// <param name="filename">Path of raster graphics image relative to the data folder.</param>
-		/// <returns>Dimensions (width/height) of this image.</returns>
 		public abstract Size DetermineImageSize(string filename);
 
-		/// <summary>Bring previous back buffer to the front.</summary>
 		public abstract void SwapBuffers();
 
-		/// <summary>Quit game. This should only be used on the Desktop.</summary>
 		public abstract void Quit();
 
 		#region Mouse related
-		/// <summary>Move the mouse cursor to the center of the game window.</summary>
 		public abstract void CenterMouse();
 
-		/// <summary>If mouse lock is active the mouse cursor gets prevented from moving out of the game window.</summary>
-		/// <param name="doLock">True iff. mouse lock should be activated.</param>
 		public abstract void SetMouseLock(bool doLock);
 
-		/// <summary>Change visibility of mouse cursor.</summary>
-		/// <param name="visible">True iff. mouse cursor should be visible.</param>
 		public abstract void SetCursorVisibility(bool visible);
 		#endregion
 
 		#region File I/O
 
 		#region Assets
-		/// <summary>Read buffered asset data.</summary>
-		/// <param name="filename">Path relative to the game's data folder.</param>
-		/// <returns>StreamReader object for reading the asset with given filename.</returns>
 		public abstract StreamReader StreamReaderForAsset(string filename);
 
-		/// <summary>Determine the path of an asset with given filename.</summary>
-		/// <param name="filename">Path relative to the game's data folder.</param>
-		/// <returns>Path of asset with filename.</returns>
 		public string PathForAsset(string filename) {
 			StreamReader reader = Globals.Platform.StreamReaderForAsset(filename);
 			string path = ((FileStream) (reader.BaseStream)).Name;
 			return path;
 		}
 
-		/// <summary>Get text content of an asset. Only use with text files.</summary>
-		/// <param name="filename">Path to the asset relative to the game's data folder.</param>
-		/// <returns>Entire text contained in the asset.</returns>
 		public string TextContentForAsset(string filename) {
 			string outStr;
 			using(StreamReader reader = StreamReaderForAsset(filename)) {
 		#endregion
 
 		#region User data persistence
-		/// <summary>Read user data.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
-		/// <returns>FileStream for reading bytes from this file.</returns>
 		public abstract FileStream FileStreamForRead(string filename);
 
-		/// <summary>Write user data.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
-		/// <returns>FileStream for writing bytes to this file.</returns>
 		public abstract FileStream FileStreamForWrite(string filename);
 
-		/// <summary>Read buffered user data.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
-		/// <returns>StreamReader for reading text from this file.</returns>
 		public StreamReader StreamReaderForFile(string filename) {
 			return new StreamReader(FileStreamForRead(filename));
 		}
 
-		/// <summary>Write buffered user data.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
-		/// <returns>StreamWriter for writing text to this file.</returns>
 		public StreamWriter StreamWriterForFile(string filename) {
 			return new StreamWriter(FileStreamForWrite(filename));
 		}
 
-		/// <summary>Delete user file.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
 		public abstract void DeleteFile(string filename);
 
-		/// <summary>Check if user file exists.</summary>
-		/// <param name="filename">Path of the file relative to the user data folder of the game.</param>
-		/// <returns>True iff. file with given path exists in user data folder of the game.</returns>
 		public abstract bool FileExists(string filename);
 
-		/// <summary>List all files in the user data folder of the game.</summary>
-		/// <returns>List of filenames of all files in the user data folder.</returns>
 		public abstract string[] ListFiles();
 		#endregion
 
 		#endregion
 
-		/// <summary>Only implemented in iOS so far. Shows keyboard and input gets forwarded to the ITextEntryListener.</summary>
-		/// <param name="listener">A text entry listener reacting on keyboard input.</param>
 		public abstract void ShowKeyboard(ITextEntryListener listener);
 	}
 

File Platforms/Desktop/DesktopBasecode.cs

 		}
 
 		#region Implementation of IStateManager
-		/// <summary>
-		///  Sets new state and disposes previous.
-		/// </summary>
-		/// <param name='s'>
-		///  New state S. 
-		/// </param>
 		public void SetState(State s) {
 			Utils.SafeDispose(ref state);
 			state = s;
 		}
 		#endregion
 
-		/// <summary>
-		/// Starts main game loop.
-		/// </summary>
 		public void GameLoop() {
 			// Unfortunately this seems buggy on OS X and Linux
 			if(onWindows && LimitFps) {

File Platforms/Desktop/DesktopPlatform.cs

 		private readonly MainWindow mainWindow;
 		private ITextEntryListener entryListener;
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="DesktopPlatform"/> class.
-		/// </summary>
-		/// <param name='mainWindow'>
-		/// Main window.
-		/// </param>
 		public DesktopPlatform(MainWindow mainWindow) {
 			this.mainWindow = mainWindow;
 			Utils.SetupGlState();
 			return imgSize;
 		}
 
-		/// <summary>
-		/// Quit this instance.
-		/// </summary>
 		public override void Quit() {
 			mainWindow.Exit();
 		}
 
-		/// <summary>
-		/// Centers the mouse.
-		/// </summary>
 		public override void CenterMouse() {
 			if (!Globals.PhoneMode)
 				mainWindow.CenterMouse();
 				mainWindow.MouseLock = doLock;
 		}
 
-		/// <summary>
-		/// Sets the cursor visibility.
-		/// </summary>
-		/// <param name='visible'>
-		/// Visible.
-		/// </param>
 		public override void SetCursorVisibility(bool visible) {
 			mainWindow.CursorVisible = Globals.PhoneMode ? true : visible;
 		}
 
-		/// <summary>
-		/// Swaps the buffers.
-		/// </summary>
 		public override void SwapBuffers() {
 			mainWindow.SwapBuffers();
 		}
 
-		/// <summary>
-		/// Streams the reader for asset.
-		/// </summary>
-		/// <returns>
-		/// The reader for asset.
-		/// </returns>
-		/// <param name='filename'>
-		/// Filename.
-		/// </param>
 		public override StreamReader StreamReaderForAsset(string filename) {
 			return new StreamReader(DataPath(filename));
 		}
 
-		/// <summary>
-		/// Files the stream for read.
-		/// </summary>
-		/// <returns>
-		/// The stream for read.
-		/// </returns>
-		/// <param name='filename'>
-		/// Filename.
-		/// </param>
 		public override FileStream FileStreamForRead(string filename) {
 			return File.OpenRead(BasePath + filename);
 		}
 
-		/// <summary>
-		/// Files the stream for write.
-		/// </summary>
-		/// <returns>
-		/// The stream for write.
-		/// </returns>
-		/// <param name='filename'>
-		/// Filename.
-		/// </param>
 		public override FileStream FileStreamForWrite(string filename) {
 			return File.OpenWrite(BasePath + filename);
 		}
 
-		/// <summary>
-		/// Deletes the file.
-		/// </summary>
-		/// <param name='filename'>
-		/// Filename.
-		/// </param>
 		public override void DeleteFile(string filename) {
 			File.Delete(BasePath + filename);
 		}
 
-		/// <summary>
-		/// Files the exists.
-		/// </summary>
-		/// <returns>
-		/// The exists.
-		/// </returns>
-		/// <param name='filename'>
-		/// If set to <c>true</c> filename.
-		/// </param>
 		public override bool FileExists(string filename) {
 			return File.Exists(BasePath + filename);
 		}

File Rendering/AbstractMesh.cs

 		protected int VertexCount;
 		protected static readonly bool[] ClStates = new bool[4];
 
-		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.AbstractMesh"/> class.
-		/// </summary>
-		/// <param name='comps'>
-		/// Vertex components to describe coordinate layout of this mesh.
-		/// </param>
 		protected AbstractMesh(VertexComponents comps) {
 			Comps = comps;
 		}
-		#endregion
 
 		#region Overrides of IDisposable
-		/// <summary>
-		/// Releases all resource used by the <see cref="Kosu.Rendering.AbstractMesh"/> object.
-		/// </summary>
-		/// <remarks>
-		/// Call <see cref="Dispose"/> when you are finished using the <see cref="Kosu.Rendering.AbstractMesh"/>. The
-		/// <see cref="Dispose"/> method leaves the <see cref="Kosu.Rendering.AbstractMesh"/> in an unusable state. After
-		/// calling <see cref="Dispose"/>, you must release all references to the <see cref="Kosu.Rendering.AbstractMesh"/> so
-		/// the garbage collector can reclaim the memory that the <see cref="Kosu.Rendering.AbstractMesh"/> was occupying.
-		/// </remarks>
 		public abstract void Dispose();
 		#endregion
 
 		#region Rendering methods
-		/// <summary>Render this instance in its entirety as triangles.</summary>
 		public virtual void Render() {
 			Render(BeginMode.Triangles, 0, VertexCount);
 		}
 
-		/// <summary>Render the mesh as specified geometry type in its entirety.</summary>
-		/// <param name='type'>Geometry type. E.g. Triangles.</param>
 		public virtual void Render(BeginMode type) {
 			Render(type, 0, VertexCount);
 		}
 
-		/// <summary>Render starting from offset count vertices.</summary>
-		/// <param name='offset'>Offset to start from.</param>
-		/// <param name='count'>Count of vertices.</param>
 		public virtual void Render(int offset, int count) {
 			Render(BeginMode.Triangles, offset, count);
 		}
 
-		/// <summary>
-		/// Render given geometry type from offset count vertices.
-		/// </summary>
-		/// <param name="type">Geometry type. E.g. Triangles.</param>
-		/// <param name="offset">Offset to start from.</param>
-		/// <param name="count">Count of vertices.</param>
 		public abstract void Render(BeginMode type, int offset, int count);
 		#endregion
 

File Rendering/Fonts/FontBatch.cs

 			SharedTex = false;
 		}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Fonts.FontBatch"/> class.
-		/// </summary>
-		/// <param name="fontDescriptionPath"> </param>
-		/// <param name="pSize">Glyph height in pixels.</param>
-		/// <param name="pVirtualWidth">Virtual screen width. Actual width by default.</param>
-		/// <param name="pVirtualHeight">Virtual screen height. Actual height by default.</param>
-		/// <param name="texture"> </param>
 		public FontBatch(Texture texture, string fontDescriptionPath, float pSize = 12.0f, int pVirtualWidth = -1, int pVirtualHeight = -1) : base(texture) {
 			FontFile fontFile = FontLoader.Load(fontDescriptionPath);
 
 		}
 		#endregion
 
-		/// <summary>
-		/// Adds sprites for the glyphs representing this text starting from given position (x,y) scaled by factor scale.
-		/// </summary>
-		/// <param name='text'>
-		/// The text that should be displayed.
-		/// </param>
-		/// <param name='x'>
-		/// x-Coordinate X.
-		/// </param>
-		/// <param name='y'>
-		/// y-Coordinate Y.
-		/// </param>
-		/// <param name="pSize">Custom size</param>
+
 		public void Draw(string text, int x = int.MinValue, int y = int.MinValue, float pSize = -1.0f) {
 			if(pSize == -1.0f) pSize = size;
 
 			Dirty = true;
 		}
 
-		/// <summary>
-		/// Flush this instance. Actually draws the letters and clears afterwards.
-		/// Call render if you don't want to clear it.
-		/// </summary>
 		public void Flush() {
 			Render();
 			Clear();

File Rendering/Fonts/FontSpriteCache.cs

 	/// Font sprite cache. Render using the Render-method inherited from SpriteCache.
 	/// </summary>
 	public class FontSpriteCache : FontBatch {
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Fonts.FontSpriteCache"/> class.
-		/// </summary>
 		public FontSpriteCache(Texture texture, string fontDescrPath, float size = 12.0f, int virtualWidth = -1, int virtualHeight = -1) : base(texture, fontDescrPath, size, virtualWidth, virtualHeight) {}
 
-		/// <summary>
-		/// Adds the sprites for glyphs representing this text at given position scaled by given scaling factor
-		/// and optionally centered.
-		/// </summary>
-		/// <param name='x'>
-		/// x-Coordinate X.
-		/// </param>
-		/// <param name='y'>
-		/// x-Coordinate Y.
-		/// </param>
-		/// <param name='text'>
-		/// Text that should be displayed.
-		/// </param>
-		/// <param name='size'>
-		/// Glyph height in pixels.
-		/// </param>
-		/// <param name='centered'>
-		/// True iff. the text should be Centered.
-		/// </param>
 		public void AddText(int x, int y, string text, float size = -1.0f, bool centered = false) {
 			if(centered) {
 				x = int.MinValue;

File Rendering/Fonts/SimpleFont.cs

 		private const int AsciiEnd = 126;
 		private const int CharsPerRow = 27;
 		private static Dictionary<char, TexCoordRect> charToTcr = new Dictionary<char, TexCoordRect>();
+
 #if WINDOWS || MAC || LINUX
-		/// <summary>
-		/// Generate the bitmap of a font with given name.
-		/// </summary>
-		/// <param name="fontName">Font family name.</param>
-		/// <returns>Bitmap of ASCII characters with given font.</returns>
 		public static Bitmap GenerateSimpleFont(string fontName = "") {
 			var defaultFont = new Font(FontFamily.GenericMonospace, 25, FontStyle.Bold, GraphicsUnit.Pixel);
 			var font = (fontName == "") ? defaultFont : new Font(fontName, 25, FontStyle.Bold, GraphicsUnit.Pixel);
 			}
 		}
 
-		/// <summary>
-		/// Draw simple font into given cache.
-		/// </summary>
-		/// <param name="cache">SpriteCache used for drawing.</param>
-		/// <param name="text">Text that should be drawn.</param>
-		/// <param name="x">x-Coordinate of text position or -1 for centering horizontally.</param>
-		/// <param name="y">y-Coordinate of text position or -1 for centering vertically.</param>
-		/// <param name="scale">Scaling factor.</param>
 		public static void DrawSimpleFont(SpriteCache cache, string text, int x = int.MinValue, int y = int.MinValue, float scale = 1.0f) {
 			if(charToTcr.Count == 0) {
 				FillCharacterToTexCoordDict();

File Rendering/IndexedMesh.cs

 		private uint vbo;
 		private uint ibo;
 
-		/// <summary>Constructs a new indexed mesh from a .obj file at given path.</summary>
-		/// <param name="path">Path on the object file in the filesystem.</param>
-		/// <returns>Object with geometry data from the given .obj file.</returns>
 		public static IndexedMesh LoadMeshFromObjFile(string path) {
 			var mesh = new IndexedMesh(new VertexComponents(true, false, false, false));
 			var coords = new List<float>();
 			return mesh;
 		}
 
-		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.IndexedMesh"/> class.
-		/// </summary>
 		public IndexedMesh() : this(new VertexComponents()) {}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.IndexedMesh"/> class.
-		/// </summary>
-		/// <param name='comps'>
-		/// Comps.
-		/// </param>
 		public IndexedMesh(VertexComponents comps) : base(comps) {
 			GL.GenBuffers(1, out vbo);
 			GL.GenBuffers(1, out ibo);
 		}
-		#endregion
 
 		#region Implementation of IDisposable
-		/// <summary>
-		/// Releases all resource used by the <see cref="Kosu.Rendering.IndexedMesh"/> object.
-		/// </summary>
-		/// <remarks>
-		/// Call <see cref="Dispose"/> when you are finished using the <see cref="Kosu.Rendering.IndexedMesh"/>. The
-		/// <see cref="Dispose"/> method leaves the <see cref="Kosu.Rendering.IndexedMesh"/> in an unusable state. After
-		/// calling <see cref="Dispose"/>, you must release all references to the <see cref="Kosu.Rendering.IndexedMesh"/> so
-		/// the garbage collector can reclaim the memory that the <see cref="Kosu.Rendering.IndexedMesh"/> was occupying.
-		/// </remarks>
 		public override void Dispose() {
 			GL.DeleteBuffers(1, ref ibo);
 			GL.DeleteBuffers(1, ref vbo);
 		}
 		#endregion
 
-		#region Geometry data upload
-		/// <summary>Sets the geometry data.</summary>
-		/// <param name='coords'>Coordinates of the vertices. Layout according to components.</param>
-		/// <param name='indices'>Indices used to describe geometry by referring to vertex indices.</param>
 		public void SetData(float[] coords, ushort[] indices) {
 			GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
 			GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr) (coords.Length*sizeof(float)), coords, IsStatic ? BufferUsageHint.StaticDraw : BufferUsageHint.DynamicDraw);
 
 			VertexCount = indices.Length;
 		}
-		#endregion
 
-		#region Rendering methods
-		/// <summary>Render the specified type, offset and count.</summary>
-		/// <param name='type'>Type of geometry being rendered (e.g. Triangles).</param>
-		/// <param name='offset'>Offset of first vertex coordinate used.</param>
-		/// <param name='count'>Count of vertices being drawn.</param>
 		public override void Render(BeginMode type, int offset, int count) {
 			GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
 			GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
 			GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
 			GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
 		}
-		#endregion
 	}
 }

File Rendering/Mesh.cs

 		private uint vao;
 #endif
 
-		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Mesh"/> class.
-		/// </summary>
 		public Mesh() : this(new VertexComponents()) {}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Mesh"/> class.
-		/// </summary>
-		/// <param name='comps'>
-		/// Comps.
-		/// </param>
 		public Mesh(VertexComponents comps) : base(comps) {
 #if USE_VAO
 			GL.GenVertexArrays(1, out vao);
 			LeakChecker<Mesh>.CheckAlloc(this);
 #endif
 		}
-		#endregion
 
 		#region IDisposable Members
-		/// <summary>
-		/// Releases all resource used by the <see cref="Kosu.Rendering.Mesh"/> object.
-		/// </summary>
-		/// <remarks>
-		/// Call <see cref="Dispose"/> when you are finished using the <see cref="Kosu.Rendering.Mesh"/>. The
-		/// <see cref="Dispose"/> method leaves the <see cref="Kosu.Rendering.Mesh"/> in an unusable state. After calling
-		/// <see cref="Dispose"/>, you must release all references to the <see cref="Kosu.Rendering.Mesh"/> so the garbage
-		/// collector can reclaim the memory that the <see cref="Kosu.Rendering.Mesh"/> was occupying.
-		/// </remarks>
 		public override void Dispose() {
 			GL.DeleteBuffers(1, ref vbo);
 #if USE_VAO
 		#endregion
 
 		#region Geometry data upload
-		/// <summary>Sets the geometry data.</summary>
-		/// <param name='coords'>Vertex coordinates. Layout according to its components.</param>
 		public void SetData(float[] coords) {
 			SetData(coords, coords.Length);
 		}
 
-		/// <summary>Sets the geometry data.</summary>
-		/// <param name='coords'>Vertex coordinates. Layout according to its components.</param>
-		/// <param name='size'>Size (that is number of coords actually used).</param>
 		public void SetData(float[] coords, int size) {
 			VertexCount = size/Comps.NumCoordsPerVx;
 
 		}
 		#endregion
 
-		#region Rendering methods
-		/// <summary>
-		/// Render the specified type, offset and count.
-		/// </summary>
-		/// <param name='type'>
-		/// Type of geometry being rendered. E.g. Triangles.
-		/// </param>
-		/// <param name='offset'>
-		/// Offset of vertex from which to start rendering.
-		/// </param>
-		/// <param name='count'>
-		/// Count of vertices to be rendered.
-		/// </param>
 		public override void Render(BeginMode type, int offset, int count) {
 			if(VertexCount == 0) return;
 #if USE_VAO
 			GL.BindVertexArray(0);
 #endif
 		}
-		#endregion
 	}
 }

File Rendering/PosColVertex.cs

 	/// Represents a vertex with position and color coordinates.
 	/// </summary>
 	public struct PosColVertex {
-		/// <summary>Vertex position.</summary>
 		public float X, Y, Z;
-		/// <summary>Vertex color (r,g,b) and opaqueness (a).</summary>
 		public float R, G, B, A;
 
-		/// <summary>
-		/// Construct a new object with given field values.
-		/// </summary>
-		/// <param name="x">x-Coordinate of the vertex position.</param>
-		/// <param name="y">y-Coordinate of the vertex position.</param>
-		/// <param name="z">z-Coordinate of the vertex position.</param>
-		/// <param name="r">red value of the vertex color.</param>
-		/// <param name="g">green value of the vertex color.</param>
-		/// <param name="b">blue value of the vertex color.</param>
-		/// <param name="a">alpha value of the vertex color.</param>
 		public PosColVertex(float x, float y, float z, float r, float g, float b, float a) {
 			X = x;
 			Y = y;
 			A = a;
 		}
 
-		/// <summary>Convert to array of floats with ...,x,y,z,r,g,b,a,... elements for each vertex.</summary>
-		/// <param name="tuples">Array of vertices to be converted in float array.</param>
-		/// <returns>Single precision floating point decimals array for given vertices.</returns>
 		public static float[] ToFloatCoords(PosColVertex[] tuples) {
 			const int vxSize = VertexComponents.NumPosColCoords;
 			var coords = new float[tuples.Length*vxSize];

File Rendering/ShaderProgram.cs

 		private readonly int fragmentShaderId;
 		private readonly int programId;
 
-		/// <summary>
-		/// Create a shader program from shaders stored in the game's assets. Factory method.
-		/// </summary>
-		/// <param name="vertexShaderPath">Path of a textfile containing the vertex shader source relative to the game's data folder.</param>
-		/// <param name="fragmentShaderPath">Path of a textfile containing the fragment shader source relative to the game's data folder.</param>
-		/// <returns>A shader program ready for use.</returns>
 		public static ShaderProgram FromAssets(string vertexShaderPath, string fragmentShaderPath) {
 			string vxStr = Globals.Platform.TextContentForAsset(vertexShaderPath);
 			string fragStr = Globals.Platform.TextContentForAsset(fragmentShaderPath);
 			return new ShaderProgram(vxStr, fragStr);
 		}
 
-		/// <summary>
-		/// Create a shader program from shaders with source given as strings. Factory method.
-		/// </summary>
-		/// <param name="vxShaderSrc">Vertex shader source string.</param>
-		/// <param name="fragShaderSrc">Fragment shader source string.</param>
-		/// <returns>A shader program ready for use.</returns>
 		public static ShaderProgram FromSourceStrings(string vxShaderSrc, string fragShaderSrc) {
 			return new ShaderProgram(vxShaderSrc, fragShaderSrc);
 		}
 
-		#region Constructors
 		private ShaderProgram(string vertexShader, string fragmentShader) {
 			vertexShaderId = GL.CreateShader(ShaderType.VertexShader);
 			GL.ShaderSource(vertexShaderId, vertexShader);
 			GL.UseProgram(programId);
 			CheckProgramStatus(programId);
 		}
-		#endregion
 
 		#region Implementation of IDisposable
-		/// <summary>Dispose this shader program. Always call after not using it anymore to avoid leaks.</summary>
 		public void Dispose() {
 			GL.UseProgram(0);
 
 		}
 		#endregion
 
-		/// <summary>Use this shader program for subsequent rendering calls.</summary>
 		public void Use() {
 			GL.UseProgram(programId);
 		}
 
 		#region Modify uniforms
-		/// <summary>Set uniform to given float value.</summary>
-		/// <param name="name">Name of the float uniform in the GLSL source text.</param>
-		/// <param name="x">Single precision floating point value.</param>
 		public void SetUniform(string name, float x) {
 			int location = GL.GetUniformLocation(programId, name);
 			GL.Uniform1(location, x);
 		}
 
-		/// <summary>Set uniform to given integer value.</summary>
-		/// <param name="name">Name of the int uniform in the GLSL source text.</param>
-		/// <param name="x">32-bit integer value.</param>
 		public void SetUniform(string name, int x) {
 			int location = GL.GetUniformLocation(programId, name);
 			GL.Uniform1(location, x);
 		}
 
-		/// <summary>Set uniform to given float 3d vector.</summary>
-		/// <param name="name">Name of the vec3 uniform in the GLSL source text.</param>
-		/// <param name="v">3d float vector.</param>
 		public void SetUniform(string name, Vector3 v) {
 			int location = GL.GetUniformLocation(programId, name);
 			GL.Uniform3(location, v.X, v.Y, v.Z);
 		}
 
-		/// <summary>Set uniform to given float 4x4 matrix.</summary>
-		/// <param name="name">Name of the mat4 uniform in the GLSL source text.</param>
-		/// <param name="a">4x4 float matrix.</param>
 		public void SetUniform(string name, Matrix4 a) {
 			int location = GL.GetUniformLocation(programId, name);
 			GL.UniformMatrix4(location, 1, false, ref a.M11);

File Rendering/Sprites/Sprite.cs

 	/// A sprite is a part of a texture being rendered with certain dimension and alpha opaqueness.
 	/// </summary>
 	public class Sprite {
-		#region Texture coordinate bounds
-		/// <summary>
-		/// Biggest texture coordinate value on the horizontal axis.
-		/// </summary>
 		public float MaxU;
-		/// <summary>
-		/// Biggest texture coordinate value on the vertical axis.
-		/// </summary>
 		public float MaxV;
-		/// <summary>
-		/// Smallest texture coordinate value on the horizontal axis.
-		/// </summary>
 		public float MinU;
-		/// <summary>
-		/// Smallest texture coordinate value on the vertical axis.
-		/// </summary>
 		public float MinV;
-		#endregion
 
-		#region Dimensions
-		/// <summary>
-		/// Width.
-		/// </summary>
 		public int W;
-		/// <summary>
-		/// Height.
-		/// </summary>
 		public int H;
-		#endregion
 
-		/// <summary>
-		/// The alpha-value used for blending.
-		/// </summary>
 		public float Alpha;
 
 		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Sprites.Sprite"/> class.
-		/// Copy-constructor.
-		/// </summary>
-		/// <param name='o'>
-		/// Another sprite o.
-		/// </param>
 		public Sprite(Sprite o) : this(o.MinU, o.MaxU, o.MinV, o.MaxV, o.W, o.H) {}
 
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Sprites.Sprite"/> class.
-		/// </summary>
-		/// <param name='minU'>
-		/// Minimum u.
-		/// </param>
-		/// <param name='maxU'>
-		/// Maximum u.
-		/// </param>
-		/// <param name='minV'>
-		/// Minimum v.
-		/// </param>
-		/// <param name='maxV'>
-		/// Maximum v.
-		/// </param>
-		/// <param name='w'>
-		/// Width W.
-		/// </param>
-		/// <param name='h'>
-		/// Height H.
-		/// </param>
-		/// <param name='alpha'>
-		/// Alpha value used for blending.
-		/// </param>
 		public Sprite(float minU, float maxU, float minV, float maxV, int w, int h, float alpha = 1.0f) {
 			MaxU = maxU;
 			MaxV = maxV;
 		}
 		#endregion
 
-		/// <summary>
-		/// Extracts only the texture coordinate part of this sprite (no size).
-		/// </summary>
-		/// <returns>
-		/// The tex coordinate rectangle of this sprite.
-		/// </returns>
 		public TexCoordRect AsTexCoordRect() {
 			return new TexCoordRect(MinU, MaxU, MinV, MaxV);
 		}

File Rendering/Sprites/SpriteBatch.cs

 		private readonly SpriteCache cache;
 
 		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Sprites.SpriteBatch"/> class.
-		/// </summary>
-		/// <param name='textureName'>
-		/// Texture name.
-		/// </param>
-		/// <param name='hasColor'>
-		/// Has color.
-		/// </param>
 		public SpriteBatch(string textureName, bool hasColor = false) {
 			cache = new SpriteCache(textureName, hasColor);
 		}
 		#endregion
 
 		#region Drawing methods
-		/// <summary>
-		/// Draw the specified sprite at position given by its coordinates (x,y).
-		/// </summary>
-		/// <param name='spr'>
-		/// A sprite (texture coordinates and size)
-		/// </param>
-		/// <param name='x'>
-		/// Position on x-Axis X.
-		/// </param>
-		/// <param name='y'>
-		/// Position on y-Axis Y.
-		/// </param>
 		public void Draw(Sprite spr, int x, int y) {
 			cache.AddSpr(new TranslatedSprite(spr, x, y));
 		}
 		}
 		#endregion
 
-		/// <summary>
-		/// Flush this instance. Renders this batch and clears it afterwards.
-		/// </summary>
 		public void Render() {
 			cache.Render();
 			cache.Clear();

File Rendering/Sprites/SpriteCache.cs

 		protected Texture Tex;
 		protected bool SharedTex;
 
-		#region Constructors
-		/// <summary>
-		/// Initializes a new instance of the <see cref="Kosu.Rendering.Sprites.SpriteCache"/> class.
-		/// </summary>
-		/// <param name="texturePath"> </param>
-		/// <param name='hasColor'>
-		/// Is a color component used? Set this to true if you need blending (transparency)!
-		/// </param>
-		/// <param name="nearestFiltering"> </param>
 		public SpriteCache(string texturePath, bool hasColor = false, bool nearestFiltering = false) : base(new VertexComponents(true, true, hasColor)) {
 			Tex = new Texture(texturePath, nearestFiltering);
 			SharedTex = false;
 			Tex = tex;
 			SharedTex = true;
 		}
-		#endregion
 
 		#region IDisposable overrides
 		public override void Dispose() {
 		#endregion
 
 		#region Modify contents of cache
-		/// <summary>
-		/// Get the name of the sprite in which the point with given coordinate (px,py) falls into.
-		/// </summary>
-		/// <returns>
-		/// Name of the sprite pointed at.
-		/// </returns>
-		/// <param name='px'>
-		/// x-Coordinate of the pointing position.
-		/// </param>
-		/// <param name='py'>
-		/// y-Coordinate of the pointing position.
-		/// </param>
 		public string NameOfPointed(int px, int py) {
 			foreach(var entry in namedSprites) {
 				if(entry.Value.PointInside(px, py)) {
 			return "";
 		}
 
-		/// <summary>
-		/// Add a translated/positioned sprite with given name.
-		/// </summary>
-		/// <param name='spr'>
-		/// A positioned sprite (texcoords & size).
-		/// </param>
-		/// <param name='name'>
-		/// Name used for later referencing of this sprite.
-		/// </param>
 		public void AddSpr(TranslatedSprite spr, string name) {
 			namedSprites.Add(name, spr);
 			AddSpr(spr);
 		}
 
-		/// <summary>
-		/// Adds an unnamed (unable to reference later) translated sprite.
-		/// </summary>
-		/// <param name='spr'>
-		/// A positioned sprite (texcoords & size).
-		/// </param>
 		public void AddSpr(TranslatedSprite spr) {
 			sprites.Add(spr);
 			curSize++;
 			Dirty = true;
 		}
 
-		/// <summary>
-		/// Adds an unnamed (unable to reference later) sprite translated at given position.
-		/// </summary>
-		/// <param name="spr">A sprite (texcoords & size).</param>
-		/// <param name="x">Position on horizontal x-Axis.</param>
-		/// <param name="y">Position on vertical y-Axis.</param>
 		public void AddSpr(Sprite spr, int x, int y) {
 			AddSpr(new TranslatedSprite(spr, x, y));
 		}
 
-		/// <summary>
-		/// Removes the sprite with given name from this cache.
-		/// </summary>
-		/// <param name='name'>
-		/// The name that was given to this sprite before when adding.
-		/// </param>
 		public void RemoveSpr(string name) {
 			if(!namedSprites.ContainsKey(name)) return;
 			TranslatedSprite toRemove = namedSprites[name];
 			Dirty = true;
 		}
 
-		/// <summary>
-		/// Clear this instance. Removes all sprites.
-		/// </summary>
 		public void Clear() {
 			sprites.Clear();
 			namedSprites.Clear();
 			Dirty = true;
 		}
 
-		/// <summary>
-		/// Moves the sprite to the position given by its coordinates.
-		/// </summary>
-		/// <param name='name'>
-		/// The name of the sprite that was given to it when adding.
-		/// </param>