2.1.0.0 -> 2.1.0.2
+ Version numbers changed. Now they correspond to the OpenGL version that is translated.
+ All delegate signatures and delegate declarations now reside in the static internal Delegates class.
	+ Added an empty static constructor to the Delegates class to ensure proper initialization.
	+ This means we no longer have expose functions with trailing underscores in the public API.
	+ It also simplifies the translation code (less "gl" and trailing underscores prefixes to work with).
+ All import signatures now reside in the static internal Imports class.
	+ Added an empty static constructor to the Imports class to ensure proper initialization.
+ Added wrapper functions for all OpenGL functions.
	+ This provides a homogenous API to the user (only functions are exposed, not delegates mixed with functions).
	+ It also allows to produce proper inline documentation blocks (though they are empty for the time being).
	+ Most wrappers just call the underlying Delegate, but some need to do additional work.
+ Removed several functions that are not used by the SpecWriter anymore.
	+ Beautified SpecWriter output.
	+ Updated the static constructor - now it will correctly identify all statically exported functions and use the corresponding Import. This works for all platforms.
+ Removed the Typemap.txt document from the Data folder as it was not used, and corrected several typemap definitions.
+ Added a new special case to the SpecReaders. Now both charPointerARB and CharPointer types are correctly mapped. This fixes some reported problems with function wrappers.
+ The function class now contains a Body property. This contains the function definition and is used by Wrappers.
+ Added a solution folder for typemaps to prebuild.xml.
+ Added a newline before printing "Press any key to continue..."


0.7.5 -> 0.7.6
+ Changed the name of cs_types.txt and gl_types.txt to cstypes.tm and gl.tm.
+ Updated to the latest opengl specs (2.1, were 2.0 before) - needed some new types in cstypes.tm.
+ Added NeedWrapper and WrapperType properties to each parameter (needed for more fince grained control on wrapper generation).
+ Added Function, Parameter, ParameterCollection (deep) copy constructors. This allows simpler code in many places (since we can now create new Functions without fear of affecting the old ones, for example).
+ Merged the ParameterCollection.cs with Parameter.cs
+ Added the FunctionBody class which contains the contents of a function as a list of strings. It is mainly intended for wrappers (allows cleaner code, too).
+ The wrapper generation now happens in TranlateSpecs.cs instead of WriteSpecs.cs. (Translations and generations should only happen during the translation phase, not while reading or writing. Allow for cleaner code).
+ Revamped the wrapper generator code. Now it handles correctly the cases where a function has more than one parameter that needs wrapping (i.e. it generates all permutations correctly). This is handled by recursively generating the needed permutations (it was a hell to implement).
+ Started documenting internals.
+ Added several new regions.
+ Removed several commented-out regions and some obsolete functions.
+ Reverted the addition of empty XML docs to each and every function and constant. These made the doc generation to take too long (and the docs would be empty, so there is no point, yet).
+ Added #pragma warning disable / restore 1591 to supress warnings about the missing XML docs (see above item).
+ Some other minor changes.

0.7.5.1 -> 0.7.5.2
+ Added translation for out char[] parameters (they are treated as StringBuilders, as specified in MSDN).
+ Added System.Text using directive.

0.7.5 -> 0.7.5.1
+ Documentation updates

0.7.4 -> 0.7.5
+ All Tao examples compile now!
+ Added wrappers for all functions that accept arrays. Permitted parameters for these are: an array of the original type (e.g. float[]), an IntPtr (if you manage memory yourself), or any blittable type (e.g. float[,,]). No type checking is done in the last case, so be careful!
+ Updated the wrappers for all functions that accept or return void pointers. Permitted parameters for these are: an IntPtr or any blittable type (type checking is turned off, so be extra careful!)
+ Aliased the GLbool type to int. It is hacky, but the examples bundled with Tao rely on this...
+ Added a wrapper for glLineStipple. Now you can pass an int to it, but only the last 16 bits will be used for the stipple (as per the function specification). This was the only way to avoid aliasing the parameter to ushort (non-CLS compatible) or having the user write unchecked((short)0x....) every time he used the function.
+ Added the WrapperType enum. Every function has a Property that indicates the wrapper it will need. This cleans up the WriteWrappers function somewhat.
+ Added the PreviousType property to the Function class. This is used when generating wrappers for functions with type-checked arrays (e.g. float[] arrays etc).
+ Corrected some type aliases in cs_types.txt
+ Added the missing wrappers for glReadPixels! (this falls in the out void array).

0.7.3 -> 0.7.4
+ Added the new typemap code, which allows opengl types to be aliased to the equivalent CLS types.
+ Used the above to change uint constants to CLS compliant ints.
+ Merged GlWrappers.cs and Gl.cs. Maybe the assembly compilation can be be done as a postprocess step to bind.
+ Some minor bugfixes.
+ Added the GLSL example (depends on GLFW and GLU).
+ Updated NeHe.Lesson06 to use ints instead of uints.
