Binding C-Libraries to .NET (C#) -- Copyright SuperTux#

supertux-freetype.cs

/* WARNING: Automatically generated file */
using System;
using System.Runtime.InteropServices;
using System.Security;

using System.Collections;
    

namespace FreeType {
	[StructLayout(LayoutKind.Sequential)]
	public struct MemoryRec_ {
		public IntPtr /*void*/ user;
		public IntPtr /* funcptr */ alloc;
		public IntPtr /* funcptr */ free;
		public IntPtr /* funcptr */ realloc;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct StreamRec {
		public IntPtr /*byte*/ _base;
		public uint size;
		public uint pos;
		public StreamDesc descriptor;
		public StreamDesc pathname;
		public IntPtr /* funcptr */ read;
		public IntPtr /* funcptr */ close;
		public IntPtr /*MemoryRec_*/ memory;
		public IntPtr /*byte*/ cursor;
		public IntPtr /*byte*/ limit;
	}

	[StructLayout(LayoutKind.Explicit)]
	public struct StreamDesc {
		[FieldOffset(0)]
		public int _value;
		[FieldOffset(0)]
		public IntPtr /*void*/ pointer;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Vector {
		public int x;
		public int y;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct BBox {
		public int xMin;
		public int yMin;
		public int xMax;
		public int yMax;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Bitmap {
		public int rows;
		public int width;
		public int pitch;
		public IntPtr /*byte*/ buffer;
		public short num_grays;
		public sbyte pixel_mode;
		public sbyte palette_mode;
		public IntPtr /*void*/ palette;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Outline {
		public short n_contours;
		public short n_points;
		public IntPtr /*Vector*/ points;
		public IntPtr /*sbyte*/ tags;
		public IntPtr /*short*/ contours;
		public int flags;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Outline_Funcs {
		public IntPtr /* funcptr */ move_to;
		public IntPtr /* funcptr */ line_to;
		public IntPtr /* funcptr */ conic_to;
		public IntPtr /* funcptr */ cubic_to;
		public int shift;
		public int delta;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct RasterRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Span {
		public short x;
		public ushort len;
		public byte coverage;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Raster_Params {
		public IntPtr /*Bitmap*/ target;
		public IntPtr /*void*/ source;
		public int flags;
		public IntPtr /* funcptr */ gray_spans;
		public IntPtr /* funcptr */ black_spans;
		public IntPtr /* funcptr */ bit_test;
		public IntPtr /* funcptr */ bit_set;
		public IntPtr /*void*/ user;
		public BBox clip_box;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Raster_Funcs {
		public Glyph_Format glyph_format;
		public IntPtr /* funcptr */ raster_new;
		public IntPtr /* funcptr */ raster_reset;
		public IntPtr /* funcptr */ raster_set_mode;
		public IntPtr /* funcptr */ raster_render;
		public IntPtr /* funcptr */ raster_done;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct UnitVector {
		public short x;
		public short y;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Matrix {
		public int xx;
		public int xy;
		public int yx;
		public int yy;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Data {
		public IntPtr /*byte*/ pointer;
		public int length;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Generic {
		public IntPtr /*void*/ data;
		public IntPtr /* funcptr */ finalizer;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ListNodeRec {
		public IntPtr /*ListNodeRec*/ prev;
		public IntPtr /*ListNodeRec*/ next;
		public IntPtr /*void*/ data;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ListRec {
		public IntPtr /*ListNodeRec*/ head;
		public IntPtr /*ListNodeRec*/ tail;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Glyph_Metrics {
		public int width;
		public int height;
		public int horiBearingX;
		public int horiBearingY;
		public int horiAdvance;
		public int vertBearingX;
		public int vertBearingY;
		public int vertAdvance;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Bitmap_Size {
		public short height;
		public short width;
		public int size;
		public int x_ppem;
		public int y_ppem;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct LibraryRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ModuleRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct DriverRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct RendererRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct FaceRec {
		public int num_faces;
		public int face_index;
		public int face_flags;
		public int style_flags;
		public int num_glyphs;
		public IntPtr /*sbyte*/ family_name;
		public IntPtr /*sbyte*/ style_name;
		public int num_fixed_sizes;
		public IntPtr /*Bitmap_Size*/ available_sizes;
		public int num_charmaps;
		public IntPtr /*IntPtr CharMapRec*/ charmaps;
		public Generic generic;
		public BBox bbox;
		public ushort units_per_EM;
		public short ascender;
		public short descender;
		public short height;
		public short max_advance_width;
		public short max_advance_height;
		public short underline_position;
		public short underline_thickness;
		public IntPtr /*GlyphSlotRec*/ glyph;
		public IntPtr /*SizeRec*/ size;
		public IntPtr /*CharMapRec*/ charmap;
		public IntPtr /*DriverRec_*/ driver;
		public IntPtr /*MemoryRec_*/ memory;
		public IntPtr /*StreamRec*/ stream;
		public ListRec sizes_list;
		public Generic autohint;
		public IntPtr /*void*/ extensions;
		public IntPtr /*Face_InternalRec_*/ _internal;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct SizeRec {
		public IntPtr /*FaceRec*/ face;
		public Generic generic;
		public Size_Metrics metrics;
		public IntPtr /*Size_InternalRec_*/ _internal;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct GlyphSlotRec {
		public IntPtr /*LibraryRec_*/ library;
		public IntPtr /*FaceRec*/ face;
		public IntPtr /*GlyphSlotRec*/ next;
		public uint reserved;
		public Generic generic;
		public Glyph_Metrics metrics;
		public int linearHoriAdvance;
		public int linearVertAdvance;
		public Vector advance;
		public Glyph_Format format;
		public Bitmap bitmap;
		public int bitmap_left;
		public int bitmap_top;
		public Outline outline;
		public uint num_subglyphs;
		public IntPtr /*SubGlyphRec_*/ subglyphs;
		public IntPtr /*void*/ control_data;
		public int control_len;
		public int lsb_delta;
		public int rsb_delta;
		public IntPtr /*void*/ other;
		public IntPtr /*Slot_InternalRec_*/ _internal;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct CharMapRec {
		public IntPtr /*FaceRec*/ face;
		public Encoding encoding;
		public ushort platform_id;
		public ushort encoding_id;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Face_InternalRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Size_InternalRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Size_Metrics {
		public ushort x_ppem;
		public ushort y_ppem;
		public int x_scale;
		public int y_scale;
		public int ascender;
		public int descender;
		public int height;
		public int max_advance;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct SubGlyphRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Slot_InternalRec_ {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Parameter {
		public uint tag;
		public IntPtr /*void*/ data;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Open_Args {
		public uint flags;
		public IntPtr /*byte*/ memory_base;
		public int memory_size;
		public IntPtr /*sbyte*/ pathname;
		public IntPtr /*StreamRec*/ stream;
		public IntPtr /*ModuleRec_*/ driver;
		public int num_params;
		public IntPtr /*Parameter*/ _params;
	}



	public enum Pixel_Mode {
		PIXEL_MODE_NONE = 0,
		PIXEL_MODE_MONO,
		PIXEL_MODE_GRAY,
		PIXEL_MODE_GRAY2,
		PIXEL_MODE_GRAY4,
		PIXEL_MODE_LCD,
		PIXEL_MODE_LCD_V,
		PIXEL_MODE_MAX,
	}

	public enum Glyph_Format {
		GLYPH_FORMAT_NONE = (int) ((uint) 0 << 24 | (uint) 0 << 16 | (uint) 0 << 8 | (uint) 0),
		GLYPH_FORMAT_COMPOSITE = (int) ((uint) 'c' << 24 | (uint) 'o' << 16 | (uint) 'm' << 8 | (uint) 'p'),
		GLYPH_FORMAT_BITMAP = (int) ((uint) 'b' << 24 | (uint) 'i' << 16 | (uint) 't' << 8 | (uint) 's'),
		GLYPH_FORMAT_OUTLINE = (int) ((uint) 'o' << 24 | (uint) 'u' << 16 | (uint) 't' << 8 | (uint) 'l'),
		GLYPH_FORMAT_PLOTTER = (int) ((uint) 'p' << 24 | (uint) 'l' << 16 | (uint) 'o' << 8 | (uint) 't'),
	}

	public enum Encoding {
		ENCODING_NONE = (int) ((uint) 0 << 24 | (uint) 0 << 16 | (uint) 0 << 8 | (uint) 0),
		ENCODING_MS_SYMBOL = (int) ((uint) 's' << 24 | (uint) 'y' << 16 | (uint) 'm' << 8 | (uint) 'b'),
		ENCODING_UNICODE = (int) ((uint) 'u' << 24 | (uint) 'n' << 16 | (uint) 'i' << 8 | (uint) 'c'),
		ENCODING_SJIS = (int) ((uint) 's' << 24 | (uint) 'j' << 16 | (uint) 'i' << 8 | (uint) 's'),
		ENCODING_GB2312 = (int) ((uint) 'g' << 24 | (uint) 'b' << 16 | (uint) ' ' << 8 | (uint) ' '),
		ENCODING_BIG5 = (int) ((uint) 'b' << 24 | (uint) 'i' << 16 | (uint) 'g' << 8 | (uint) '5'),
		ENCODING_WANSUNG = (int) ((uint) 'w' << 24 | (uint) 'a' << 16 | (uint) 'n' << 8 | (uint) 's'),
		ENCODING_JOHAB = (int) ((uint) 'j' << 24 | (uint) 'o' << 16 | (uint) 'h' << 8 | (uint) 'a'),
		ENCODING_MS_SJIS = (int) (Encoding.ENCODING_SJIS),
		ENCODING_MS_GB2312 = (int) (Encoding.ENCODING_GB2312),
		ENCODING_MS_BIG5 = (int) (Encoding.ENCODING_BIG5),
		ENCODING_MS_WANSUNG = (int) (Encoding.ENCODING_WANSUNG),
		ENCODING_MS_JOHAB = (int) (Encoding.ENCODING_JOHAB),
		ENCODING_ADOBE_STANDARD = (int) ((uint) 'A' << 24 | (uint) 'D' << 16 | (uint) 'O' << 8 | (uint) 'B'),
		ENCODING_ADOBE_EXPERT = (int) ((uint) 'A' << 24 | (uint) 'D' << 16 | (uint) 'B' << 8 | (uint) 'E'),
		ENCODING_ADOBE_CUSTOM = (int) ((uint) 'A' << 24 | (uint) 'D' << 16 | (uint) 'B' << 8 | (uint) 'C'),
		ENCODING_ADOBE_LATIN_1 = (int) ((uint) 'l' << 24 | (uint) 'a' << 16 | (uint) 't' << 8 | (uint) '1'),
		ENCODING_OLD_LATIN_2 = (int) ((uint) 'l' << 24 | (uint) 'a' << 16 | (uint) 't' << 8 | (uint) '2'),
		ENCODING_APPLE_ROMAN = (int) ((uint) 'a' << 24 | (uint) 'r' << 16 | (uint) 'm' << 8 | (uint) 'n'),
	}

	public enum Render_Mode {
		RENDER_MODE_NORMAL = 0,
		RENDER_MODE_LIGHT,
		RENDER_MODE_MONO,
		RENDER_MODE_LCD,
		RENDER_MODE_LCD_V,
		RENDER_MODE_MAX,
	}

	public enum Kerning_Mode {
		KERNING_DEFAULT = 0,
		KERNING_UNFITTED,
		KERNING_UNSCALED,
	}

	public class FT {

            private const string FT_DLL = "freetype.dll";
                public static Hashtable ErrorStrings ;
            static FT() {
                ErrorStrings = new Hashtable();
  ErrorStrings[0x00] = "no error";


  ErrorStrings[0x01] = "cannot open resource";

  ErrorStrings[0x02] = "unknown file format";

  ErrorStrings[0x03] = "broken file";

  ErrorStrings[0x04] = "invalid FreeType version";

  ErrorStrings[0x05] = "module version is too low";

  ErrorStrings[0x06] = "invalid argument";

  ErrorStrings[0x07] = "unimplemented feature";

  ErrorStrings[0x08] = "broken table";

  ErrorStrings[0x09] = "broken offset within table";




  ErrorStrings[0x10] = "invalid glyph index";

  ErrorStrings[0x11] = "invalid character code";

  ErrorStrings[0x12] = "unsupported glyph image format";

  ErrorStrings[0x13] = "cannot render this glyph format";

  ErrorStrings[0x14] = "invalid outline";

  ErrorStrings[0x15] = "invalid composite glyph";

  ErrorStrings[0x16] = "too many hints";

  ErrorStrings[0x17] = "invalid pixel size";




  ErrorStrings[0x20] = "invalid object handle";

  ErrorStrings[0x21] = "invalid library handle";

  ErrorStrings[0x22] = "invalid module handle";

  ErrorStrings[0x23] = "invalid face handle";

  ErrorStrings[0x24] = "invalid size handle";

  ErrorStrings[0x25] = "invalid glyph slot handle";

  ErrorStrings[0x26] = "invalid charmap handle";

  ErrorStrings[0x27] = "invalid cache manager handle";

  ErrorStrings[0x28] = "invalid stream handle";




  ErrorStrings[0x30] = "too many modules";

  ErrorStrings[0x31] = "too many extensions";




  ErrorStrings[0x40] = "out of memory";

  ErrorStrings[0x41] = "unlisted object";




  ErrorStrings[0x51] = "cannot open stream";

  ErrorStrings[0x52] = "invalid stream seek";

  ErrorStrings[0x53] = "invalid stream skip";

  ErrorStrings[0x54] = "invalid stream read";

  ErrorStrings[0x55] = "invalid stream operation";

  ErrorStrings[0x56] = "invalid frame operation";

  ErrorStrings[0x57] = "nested frame access";

  ErrorStrings[0x58] = "invalid frame read";




  ErrorStrings[0x60] = "raster uninitialized";

  ErrorStrings[0x61] = "raster corrupted";

  ErrorStrings[0x62] = "raster overflow";

  ErrorStrings[0x63] = "negative height while rastering";




  ErrorStrings[0x70] = "too many registered caches";




  ErrorStrings[0x80] = "invalid opcode";

  ErrorStrings[0x81] = "too few arguments";

  ErrorStrings[0x82] = "stack overflow";

  ErrorStrings[0x83] = "code overflow";

  ErrorStrings[0x84] = "bad argument";

  ErrorStrings[0x85] = "division by zero";

  ErrorStrings[0x86] = "invalid reference";

  ErrorStrings[0x87] = "found debug opcode";

  ErrorStrings[0x88] = "found ENDF opcode in execution stream";

  ErrorStrings[0x89] = "nested DEFS";

  ErrorStrings[0x8A] = "invalid code range";

  ErrorStrings[0x8B] = "execution context too long";

  ErrorStrings[0x8C] = "too many function definitions";

  ErrorStrings[0x8D] = "too many instruction definitions";

  ErrorStrings[0x8E] = "SFNT font table missing";

  ErrorStrings[0x8F] = "horizontal header (hhea) table missing";

  ErrorStrings[0x90] = "locations (loca) table missing";

  ErrorStrings[0x91] = "name table missing";

  ErrorStrings[0x92] = "character map (cmap) table missing";

  ErrorStrings[0x93] = "horizontal metrics (hmtx) table missing";

  ErrorStrings[0x94] = "PostScript (post) table missing";

  ErrorStrings[0x95] = "invalid horizontal metrics";

  ErrorStrings[0x96] = "invalid character map (cmap) format";

  ErrorStrings[0x97] = "invalid ppem value";

  ErrorStrings[0x98] = "invalid vertical metrics";

  ErrorStrings[0x99] = "could not find context";

  ErrorStrings[0x9A] = "invalid PostScript (post) table format";

  ErrorStrings[0x9B] = "invalid PostScript (post) table";




  ErrorStrings[0xA0] = "opcode syntax error";

  ErrorStrings[0xA1] = "argument stack underflow";

  ErrorStrings[0xA2] = "ignore";




  ErrorStrings[0xB0] = "`STARTFONT' field missing";

  ErrorStrings[0xB1] = "`FONT' field missing";

  ErrorStrings[0xB2] = "`SIZE' field missing";

  ErrorStrings[0xB3] = "`CHARS' field missing";

  ErrorStrings[0xB4] = "`STARTCHAR' field missing";

  ErrorStrings[0xB5] = "`ENCODING' field missing";

  ErrorStrings[0xB6] = "`BBX' field missing";




            }

		public const uint ft_open_driver = 0x8;
		public const uint ft_open_memory = 0x1;
		public const uint ft_open_params = 0x10;
		public const uint ft_open_pathname = 0x4;
		public const uint ft_open_stream = 0x2;
		public const uint ft_outline_even_odd_fill = 0x2;
		public const uint ft_outline_high_precision = 0x100;
		public const uint ft_outline_ignore_dropouts = 0x8;
		public const uint ft_outline_none = 0x0;
		public const uint ft_outline_owner = 0x1;
		public const uint ft_outline_reverse_fill = 0x4;
		public const uint ft_outline_single_pass = 0x200;
		public const uint ft_raster_flag_aa = 0x1;
		public const uint ft_raster_flag_clip = 0x4;
		public const uint ft_raster_flag_default = 0x0;
		public const uint ft_raster_flag_direct = 0x2;
		public const int FREETYPE_MAJOR = 2;
		public const int FREETYPE_MINOR = 1;
		public const int FREETYPE_PATCH = 9;
		public const int ALIGNMENT = 8;
		public const int Curve_Tag_Conic = 0;
		public const int Curve_Tag_Cubic = 2;
		public const int Curve_Tag_On = 1;
		public const int Curve_Tag_Touch_X = 8;
		public const int Curve_Tag_Touch_Y = 16;
		public const int CURVE_TAG_CONIC = 0;
		public const int CURVE_TAG_CUBIC = 2;
		public const int CURVE_TAG_ON = 1;
		public const int CURVE_TAG_TOUCH_X = 8;
		public const int CURVE_TAG_TOUCH_Y = 16;
		public const int LOAD_CROP_BITMAP = 0x40;
		public const int LOAD_DEFAULT = 0x0;
		public const int LOAD_FORCE_AUTOHINT = 0x20;
		public const int LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH = 0x200;
		public const int LOAD_IGNORE_TRANSFORM = 0x800;
		public const int LOAD_LINEAR_DESIGN = 0x2000;
		public const int LOAD_MONOCHROME = 0x1000;
		public const int LOAD_NO_BITMAP = 0x8;
		public const int LOAD_NO_HINTING = 0x2;
		public const int LOAD_NO_RECURSE = 0x400;
		public const int LOAD_NO_SCALE = 0x1;
		public const int LOAD_PEDANTIC = 0x80;
		public const int LOAD_RENDER = 0x4;
		public const int LOAD_SBITS_ONLY = 0x4000;
		public const int LOAD_VERTICAL_LAYOUT = 0x10;
		public const int MAX_MODULES = 32;
		public const uint OPEN_DRIVER = 0x8;
		public const uint OPEN_MEMORY = 0x1;
		public const uint OPEN_PARAMS = 0x10;
		public const uint OPEN_PATHNAME = 0x4;
		public const uint OPEN_STREAM = 0x2;
		public const uint OUTLINE_EVEN_ODD_FILL = 0x2;
		public const uint OUTLINE_HIGH_PRECISION = 0x100;
		public const uint OUTLINE_IGNORE_DROPOUTS = 0x8;
		public const uint OUTLINE_NONE = 0x0;
		public const uint OUTLINE_OWNER = 0x1;
		public const uint OUTLINE_REVERSE_FILL = 0x4;
		public const uint OUTLINE_SINGLE_PASS = 0x200;
		public const uint RASTER_FLAG_AA = 0x1;
		public const uint RASTER_FLAG_CLIP = 0x4;
		public const uint RASTER_FLAG_DEFAULT = 0x0;
		public const uint RASTER_FLAG_DIRECT = 0x2;
		public const int HAVE_FCNTL_H = 1;
		public const int HAVE_UNISTD_H = 1;
		public const int T1_MAX_CHARSTRINGS_OPERANDS = 256;
		public const int T1_MAX_DICT_DEPTH = 5;
		public const int T1_MAX_SUBRS_CALLS = 16;
		public const int Mod_Err_Base = 0;
		public const int Mod_Err_Autohint = 0;
		public const int Mod_Err_BDF = 0;
		public const int Mod_Err_Cache = 0;
		public const int Mod_Err_CFF = 0;
		public const int Mod_Err_CID = 0;
		public const int Mod_Err_Gzip = 0;
		public const int Mod_Err_LZW = 0;
		public const int Mod_Err_PCF = 0;
		public const int Mod_Err_PFR = 0;
		public const int Mod_Err_PSaux = 0;
		public const int Mod_Err_PShinter = 0;
		public const int Mod_Err_PSnames = 0;
		public const int Mod_Err_Raster = 0;
		public const int Mod_Err_SFNT = 0;
		public const int Mod_Err_Smooth = 0;
		public const int Mod_Err_TrueType = 0;
		public const int Mod_Err_Type1 = 0;
		public const int Mod_Err_Type42 = 0;
		public const int Mod_Err_Winfonts = 0;
		public const int Mod_Err_Max = 1;
		public const int Err_Ok = 0x00;
		public const int Err_Cannot_Open_Resource = (int) (0x01 + 0);
		public const int Err_Unknown_File_Format = (int) (0x02 + 0);
		public const int Err_Invalid_File_Format = (int) (0x03 + 0);
		public const int Err_Invalid_Version = (int) (0x04 + 0);
		public const int Err_Lower_Module_Version = (int) (0x05 + 0);
		public const int Err_Invalid_Argument = (int) (0x06 + 0);
		public const int Err_Unimplemented_Feature = (int) (0x07 + 0);
		public const int Err_Invalid_Table = (int) (0x08 + 0);
		public const int Err_Invalid_Offset = (int) (0x09 + 0);
		public const int Err_Invalid_Glyph_Index = (int) (0x10 + 0);
		public const int Err_Invalid_Character_Code = (int) (0x11 + 0);
		public const int Err_Invalid_Glyph_Format = (int) (0x12 + 0);
		public const int Err_Cannot_Render_Glyph = (int) (0x13 + 0);
		public const int Err_Invalid_Outline = (int) (0x14 + 0);
		public const int Err_Invalid_Composite = (int) (0x15 + 0);
		public const int Err_Too_Many_Hints = (int) (0x16 + 0);
		public const int Err_Invalid_Pixel_Size = (int) (0x17 + 0);
		public const int Err_Invalid_Handle = (int) (0x20 + 0);
		public const int Err_Invalid_Library_Handle = (int) (0x21 + 0);
		public const int Err_Invalid_Driver_Handle = (int) (0x22 + 0);
		public const int Err_Invalid_Face_Handle = (int) (0x23 + 0);
		public const int Err_Invalid_Size_Handle = (int) (0x24 + 0);
		public const int Err_Invalid_Slot_Handle = (int) (0x25 + 0);
		public const int Err_Invalid_CharMap_Handle = (int) (0x26 + 0);
		public const int Err_Invalid_Cache_Handle = (int) (0x27 + 0);
		public const int Err_Invalid_Stream_Handle = (int) (0x28 + 0);
		public const int Err_Too_Many_Drivers = (int) (0x30 + 0);
		public const int Err_Too_Many_Extensions = (int) (0x31 + 0);
		public const int Err_Out_Of_Memory = (int) (0x40 + 0);
		public const int Err_Unlisted_Object = (int) (0x41 + 0);
		public const int Err_Cannot_Open_Stream = (int) (0x51 + 0);
		public const int Err_Invalid_Stream_Seek = (int) (0x52 + 0);
		public const int Err_Invalid_Stream_Skip = (int) (0x53 + 0);
		public const int Err_Invalid_Stream_Read = (int) (0x54 + 0);
		public const int Err_Invalid_Stream_Operation = (int) (0x55 + 0);
		public const int Err_Invalid_Frame_Operation = (int) (0x56 + 0);
		public const int Err_Nested_Frame_Access = (int) (0x57 + 0);
		public const int Err_Invalid_Frame_Read = (int) (0x58 + 0);
		public const int Err_Raster_Uninitialized = (int) (0x60 + 0);
		public const int Err_Raster_Corrupted = (int) (0x61 + 0);
		public const int Err_Raster_Overflow = (int) (0x62 + 0);
		public const int Err_Raster_Negative_Height = (int) (0x63 + 0);
		public const int Err_Too_Many_Caches = (int) (0x70 + 0);
		public const int Err_Invalid_Opcode = (int) (0x80 + 0);
		public const int Err_Too_Few_Arguments = (int) (0x81 + 0);
		public const int Err_Stack_Overflow = (int) (0x82 + 0);
		public const int Err_Code_Overflow = (int) (0x83 + 0);
		public const int Err_Bad_Argument = (int) (0x84 + 0);
		public const int Err_Divide_By_Zero = (int) (0x85 + 0);
		public const int Err_Invalid_Reference = (int) (0x86 + 0);
		public const int Err_Debug_OpCode = (int) (0x87 + 0);
		public const int Err_ENDF_In_Exec_Stream = (int) (0x88 + 0);
		public const int Err_Nested_DEFS = (int) (0x89 + 0);
		public const int Err_Invalid_CodeRange = (int) (0x8A + 0);
		public const int Err_Execution_Too_Long = (int) (0x8B + 0);
		public const int Err_Too_Many_Function_Defs = (int) (0x8C + 0);
		public const int Err_Too_Many_Instruction_Defs = (int) (0x8D + 0);
		public const int Err_Table_Missing = (int) (0x8E + 0);
		public const int Err_Horiz_Header_Missing = (int) (0x8F + 0);
		public const int Err_Locations_Missing = (int) (0x90 + 0);
		public const int Err_Name_Table_Missing = (int) (0x91 + 0);
		public const int Err_CMap_Table_Missing = (int) (0x92 + 0);
		public const int Err_Hmtx_Table_Missing = (int) (0x93 + 0);
		public const int Err_Post_Table_Missing = (int) (0x94 + 0);
		public const int Err_Invalid_Horiz_Metrics = (int) (0x95 + 0);
		public const int Err_Invalid_CharMap_Format = (int) (0x96 + 0);
		public const int Err_Invalid_PPem = (int) (0x97 + 0);
		public const int Err_Invalid_Vert_Metrics = (int) (0x98 + 0);
		public const int Err_Could_Not_Find_Context = (int) (0x99 + 0);
		public const int Err_Invalid_Post_Table_Format = (int) (0x9A + 0);
		public const int Err_Invalid_Post_Table = (int) (0x9B + 0);
		public const int Err_Syntax_Error = (int) (0xA0 + 0);
		public const int Err_Stack_Underflow = (int) (0xA1 + 0);
		public const int Err_Ignore = (int) (0xA2 + 0);
		public const int Err_Missing_Startfont_Field = (int) (0xB0 + 0);
		public const int Err_Missing_Font_Field = (int) (0xB1 + 0);
		public const int Err_Missing_Size_Field = (int) (0xB2 + 0);
		public const int Err_Missing_Chars_Field = (int) (0xB3 + 0);
		public const int Err_Missing_Startchar_Field = (int) (0xB4 + 0);
		public const int Err_Missing_Encoding_Field = (int) (0xB5 + 0);
		public const int Err_Missing_Bbx_Field = (int) (0xB6 + 0);

		[DllImport(FT_DLL, EntryPoint="FT_Init_FreeType"), SuppressUnmanagedCodeSecurity]
		public static extern int Init_FreeType(IntPtr /*IntPtr LibraryRec_*/ alibrary);

		[DllImport(FT_DLL, EntryPoint="FT_Library_Version"), SuppressUnmanagedCodeSecurity]
		public static extern void Library_Version(IntPtr /*LibraryRec_*/ library, [In, Out] int[] amajor, [In, Out] int[] aminor, [In, Out] int[] apatch);

		[DllImport(FT_DLL, EntryPoint="FT_Done_FreeType"), SuppressUnmanagedCodeSecurity]
		public static extern int Done_FreeType(IntPtr /*LibraryRec_*/ library);

		[DllImport(FT_DLL, EntryPoint="FT_New_Face"), SuppressUnmanagedCodeSecurity]
		public static extern int New_Face(IntPtr /*LibraryRec_*/ library, string filepathname, int face_index, IntPtr /*IntPtr FaceRec*/ aface);

		[DllImport(FT_DLL, EntryPoint="FT_New_Memory_Face"), SuppressUnmanagedCodeSecurity]
		public static extern int New_Memory_Face(IntPtr /*LibraryRec_*/ library, [In] byte[] file_base, int file_size, int face_index, IntPtr /*IntPtr FaceRec*/ aface);

		[DllImport(FT_DLL, EntryPoint="FT_Open_Face"), SuppressUnmanagedCodeSecurity]
		public static extern int Open_Face(IntPtr /*LibraryRec_*/ library, Open_Args args, int face_index, IntPtr /*IntPtr FaceRec*/ aface);

		[DllImport(FT_DLL, EntryPoint="FT_Attach_File"), SuppressUnmanagedCodeSecurity]
		public static extern int Attach_File(IntPtr /*FaceRec*/ face, string filepathname);

		[DllImport(FT_DLL, EntryPoint="FT_Attach_Stream"), SuppressUnmanagedCodeSecurity]
		public static extern int Attach_Stream(IntPtr /*FaceRec*/ face, ref Open_Args parameters);

		[DllImport(FT_DLL, EntryPoint="FT_Done_Face"), SuppressUnmanagedCodeSecurity]
		public static extern int Done_Face(IntPtr /*FaceRec*/ face);

		[DllImport(FT_DLL, EntryPoint="FT_Set_Char_Size"), SuppressUnmanagedCodeSecurity]
		public static extern int Set_Char_Size(IntPtr /*FaceRec*/ face, int char_width, int char_height, uint horz_resolution, uint vert_resolution);

		[DllImport(FT_DLL, EntryPoint="FT_Set_Pixel_Sizes"), SuppressUnmanagedCodeSecurity]
		public static extern int Set_Pixel_Sizes(IntPtr /*FaceRec*/ face, uint pixel_width, uint pixel_height);

		[DllImport(FT_DLL, EntryPoint="FT_Load_Glyph"), SuppressUnmanagedCodeSecurity]
		public static extern int Load_Glyph(IntPtr /*FaceRec*/ face, uint glyph_index, int load_flags);

		[DllImport(FT_DLL, EntryPoint="FT_Load_Char"), SuppressUnmanagedCodeSecurity]
		public static extern int Load_Char(IntPtr /*FaceRec*/ face, uint char_code, int load_flags);

		[DllImport(FT_DLL, EntryPoint="FT_Set_Transform"), SuppressUnmanagedCodeSecurity]
		public static extern void Set_Transform(IntPtr /*FaceRec*/ face, ref Matrix matrix, ref Vector delta);

		[DllImport(FT_DLL, EntryPoint="FT_Render_Glyph"), SuppressUnmanagedCodeSecurity]
		public static extern int Render_Glyph(ref GlyphSlotRec slot, Render_Mode render_mode);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Kerning"), SuppressUnmanagedCodeSecurity]
		public static extern int Get_Kerning(IntPtr /*FaceRec*/ face, uint left_glyph, uint right_glyph, uint kern_mode, out Vector akerning);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Glyph_Name"), SuppressUnmanagedCodeSecurity]
		public static extern int Get_Glyph_Name(IntPtr /*FaceRec*/ face, uint glyph_index, IntPtr buffer, uint buffer_max);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Postscript_Name"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ Get_Postscript_Name(IntPtr /*FaceRec*/ face);

		[DllImport(FT_DLL, EntryPoint="FT_Select_Charmap"), SuppressUnmanagedCodeSecurity]
		public static extern int Select_Charmap(IntPtr /*FaceRec*/ face, Encoding encoding);

		[DllImport(FT_DLL, EntryPoint="FT_Set_Charmap"), SuppressUnmanagedCodeSecurity]
		public static extern int Set_Charmap(IntPtr /*FaceRec*/ face, ref CharMapRec charmap);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Charmap_Index"), SuppressUnmanagedCodeSecurity]
		public static extern int Get_Charmap_Index(ref CharMapRec charmap);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Char_Index"), SuppressUnmanagedCodeSecurity]
		public static extern uint Get_Char_Index(IntPtr /*FaceRec*/ face, uint charcode);

		[DllImport(FT_DLL, EntryPoint="FT_Get_First_Char"), SuppressUnmanagedCodeSecurity]
		public static extern uint Get_First_Char(IntPtr /*FaceRec*/ face, [In, Out] uint[] agindex);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Next_Char"), SuppressUnmanagedCodeSecurity]
		public static extern uint Get_Next_Char(IntPtr /*FaceRec*/ face, uint char_code, [In, Out] uint[] agindex);

		[DllImport(FT_DLL, EntryPoint="FT_Get_Name_Index"), SuppressUnmanagedCodeSecurity]
		public static extern uint Get_Name_Index(IntPtr /*FaceRec*/ face, [In, Out] sbyte[] glyph_name);

		[DllImport(FT_DLL, EntryPoint="FT_MulDiv"), SuppressUnmanagedCodeSecurity]
		public static extern int MulDiv(int a, int b, int c);

		[DllImport(FT_DLL, EntryPoint="FT_MulFix"), SuppressUnmanagedCodeSecurity]
		public static extern int MulFix(int a, int b);

		[DllImport(FT_DLL, EntryPoint="FT_DivFix"), SuppressUnmanagedCodeSecurity]
		public static extern int DivFix(int a, int b);

		[DllImport(FT_DLL, EntryPoint="FT_RoundFix"), SuppressUnmanagedCodeSecurity]
		public static extern int RoundFix(int a);

		[DllImport(FT_DLL, EntryPoint="FT_CeilFix"), SuppressUnmanagedCodeSecurity]
		public static extern int CeilFix(int a);

		[DllImport(FT_DLL, EntryPoint="FT_FloorFix"), SuppressUnmanagedCodeSecurity]
		public static extern int FloorFix(int a);

		[DllImport(FT_DLL, EntryPoint="FT_Vector_Transform"), SuppressUnmanagedCodeSecurity]
		public static extern void Vector_Transform(ref Vector vec, ref Matrix matrix);


	}
}

supertux-opengl.cs

/* WARNING: Automatically generated file */
using System;
using System.Runtime.InteropServices;
using System.Security;


namespace OpenGl {
	public class gl {

        private const string GL_DLL = "GL.dll";
    
		public const uint _2_BYTES = 0x1407;
		public const uint _2D = 0x0600;
		public const uint _3_BYTES = 0x1408;
		public const uint _3D = 0x0601;
		public const uint _3D_COLOR = 0x0602;
		public const uint _3D_COLOR_TEXTURE = 0x0603;
		public const uint _4_BYTES = 0x1409;
		public const uint _4D_COLOR_TEXTURE = 0x0604;
		public const uint ABGR_EXT = 0x8000;
		public const uint ACCUM = 0x0100;
		public const uint ACCUM_ALPHA_BITS = 0x0D5B;
		public const uint ACCUM_BLUE_BITS = 0x0D5A;
		public const uint ACCUM_BUFFER_BIT = 0x00000200;
		public const uint ACCUM_CLEAR_VALUE = 0x0B80;
		public const uint ACCUM_GREEN_BITS = 0x0D59;
		public const uint ACCUM_RED_BITS = 0x0D58;
		public const uint ACTIVE_TEXTURE = 0x84E0;
		public const uint ADD = 0x0104;
		public const uint ADD_SIGNED = 0x8574;
		public const uint ALIASED_LINE_WIDTH_RANGE = 0x846E;
		public const uint ALIASED_POINT_SIZE_RANGE = 0x846D;
		public const uint ALL_ATTRIB_BITS = 0xFFFFFFFF;
		public const uint ALPHA = 0x1906;
		public const uint ALPHA_BIAS = 0x0D1D;
		public const uint ALPHA_BITS = 0x0D55;
		public const uint ALPHA_SCALE = 0x0D1C;
		public const uint ALPHA_TEST = 0x0BC0;
		public const uint ALPHA_TEST_FUNC = 0x0BC1;
		public const uint ALPHA_TEST_REF = 0x0BC2;
		public const uint ALPHA12 = 0x803D;
		public const uint ALPHA16 = 0x803E;
		public const uint ALPHA4 = 0x803B;
		public const uint ALPHA8 = 0x803C;
		public const uint ALWAYS = 0x0207;
		public const uint AMBIENT = 0x1200;
		public const uint AMBIENT_AND_DIFFUSE = 0x1602;
		public const uint AND = 0x1501;
		public const uint AND_INVERTED = 0x1504;
		public const uint AND_REVERSE = 0x1502;
		public const uint ATTRIB_STACK_DEPTH = 0x0BB0;
		public const uint AUTO_NORMAL = 0x0D80;
		public const uint AUX_BUFFERS = 0x0C00;
		public const uint AUX0 = 0x0409;
		public const uint AUX1 = 0x040A;
		public const uint AUX2 = 0x040B;
		public const uint AUX3 = 0x040C;
		public const uint BACK = 0x0405;
		public const uint BACK_LEFT = 0x0402;
		public const uint BACK_RIGHT = 0x0403;
		public const uint BGR = 0x80E0;
		public const uint BGRA = 0x80E1;
		public const uint BITMAP = 0x1A00;
		public const uint BITMAP_TOKEN = 0x0704;
		public const uint BLEND = 0x0BE2;
		public const uint BLEND_DST = 0x0BE0;
		public const uint BLEND_DST_ALPHA = 0x80CA;
		public const uint BLEND_DST_RGB = 0x80C8;
		public const uint BLEND_SRC = 0x0BE1;
		public const uint BLEND_SRC_ALPHA = 0x80CB;
		public const uint BLEND_SRC_RGB = 0x80C9;
		public const uint BLUE = 0x1905;
		public const uint BLUE_BIAS = 0x0D1B;
		public const uint BLUE_BITS = 0x0D54;
		public const uint BLUE_SCALE = 0x0D1A;
		public const uint BYTE = 0x1400;
		public const uint C3F_V3F = 0x2A24;
		public const uint C4F_N3F_V3F = 0x2A26;
		public const uint C4UB_V2F = 0x2A22;
		public const uint C4UB_V3F = 0x2A23;
		public const uint CCW = 0x0901;
		public const int CLAMP = 0x2900;
		public const int CLAMP_TO_BORDER = 0x812D;
		public const int CLAMP_TO_EDGE = 0x812F;
		public const uint CLEAR = 0x1500;
		public const uint CLIENT_ACTIVE_TEXTURE = 0x84E1;
		public const uint CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF;
		public const uint CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1;
		public const uint CLIENT_PIXEL_STORE_BIT = 0x00000001;
		public const uint CLIENT_VERTEX_ARRAY_BIT = 0x00000002;
		public const uint CLIP_PLANE0 = 0x3000;
		public const uint CLIP_PLANE1 = 0x3001;
		public const uint CLIP_PLANE2 = 0x3002;
		public const uint CLIP_PLANE3 = 0x3003;
		public const uint CLIP_PLANE4 = 0x3004;
		public const uint CLIP_PLANE5 = 0x3005;
		public const uint COEFF = 0x0A00;
		public const uint COLOR = 0x1800;
		public const uint COLOR_ARRAY = 0x8076;
		public const uint COLOR_ARRAY_COUNT_EXT = 0x8084;
		public const uint COLOR_ARRAY_EXT = 0x8076;
		public const uint COLOR_ARRAY_POINTER = 0x8090;
		public const uint COLOR_ARRAY_POINTER_EXT = 0x8090;
		public const uint COLOR_ARRAY_SIZE = 0x8081;
		public const uint COLOR_ARRAY_SIZE_EXT = 0x8081;
		public const uint COLOR_ARRAY_STRIDE = 0x8083;
		public const uint COLOR_ARRAY_STRIDE_EXT = 0x8083;
		public const uint COLOR_ARRAY_TYPE = 0x8082;
		public const uint COLOR_ARRAY_TYPE_EXT = 0x8082;
		public const uint COLOR_BUFFER_BIT = 0x00004000;
		public const uint COLOR_CLEAR_VALUE = 0x0C22;
		public const uint COLOR_INDEX = 0x1900;
		public const uint COLOR_INDEXES = 0x1603;
		public const uint COLOR_LOGIC_OP = 0x0BF2;
		public const uint COLOR_MATERIAL = 0x0B57;
		public const uint COLOR_MATERIAL_FACE = 0x0B55;
		public const uint COLOR_MATERIAL_PARAMETER = 0x0B56;
		public const uint COLOR_SUM = 0x8458;
		public const uint COLOR_WRITEMASK = 0x0C23;
		public const uint COMBINE = 0x8570;
		public const uint COMBINE_ALPHA = 0x8572;
		public const uint COMBINE_RGB = 0x8571;
		public const uint COMPARE_R_TO_TEXTURE = 0x884E;
		public const uint COMPILE = 0x1300;
		public const uint COMPILE_AND_EXECUTE = 0x1301;
		public const uint COMPRESSED_ALPHA = 0x84E9;
		public const uint COMPRESSED_INTENSITY = 0x84EC;
		public const uint COMPRESSED_LUMINANCE = 0x84EA;
		public const uint COMPRESSED_LUMINANCE_ALPHA = 0x84EB;
		public const uint COMPRESSED_RGB = 0x84ED;
		public const uint COMPRESSED_RGBA = 0x84EE;
		public const uint COMPRESSED_TEXTURE_FORMATS = 0x86A3;
		public const uint CONSTANT = 0x8576;
		public const uint CONSTANT_ATTENUATION = 0x1207;
		public const uint COPY = 0x1503;
		public const uint COPY_INVERTED = 0x150C;
		public const uint COPY_PIXEL_TOKEN = 0x0706;
		public const uint CULL_FACE = 0x0B44;
		public const uint CULL_FACE_MODE = 0x0B45;
		public const uint CURRENT_BIT = 0x00000001;
		public const uint CURRENT_COLOR = 0x0B00;
		public const uint CURRENT_FOG_COORDINATE = 0x8453;
		public const uint CURRENT_INDEX = 0x0B01;
		public const uint CURRENT_NORMAL = 0x0B02;
		public const uint CURRENT_RASTER_COLOR = 0x0B04;
		public const uint CURRENT_RASTER_DISTANCE = 0x0B09;
		public const uint CURRENT_RASTER_INDEX = 0x0B05;
		public const uint CURRENT_RASTER_POSITION = 0x0B07;
		public const uint CURRENT_RASTER_POSITION_VALID = 0x0B08;
		public const uint CURRENT_RASTER_TEXTURE_COORDS = 0x0B06;
		public const uint CURRENT_SECONDARY_COLOR = 0x8459;
		public const uint CURRENT_TEXTURE_COORDS = 0x0B03;
		public const uint CW = 0x0900;
		public const uint DECAL = 0x2101;
		public const uint DECR = 0x1E03;
		public const uint DECR_WRAP = 0x8508;
		public const uint DEPTH = 0x1801;
		public const uint DEPTH_BIAS = 0x0D1F;
		public const uint DEPTH_BITS = 0x0D56;
		public const uint DEPTH_BUFFER_BIT = 0x00000100;
		public const uint DEPTH_CLEAR_VALUE = 0x0B73;
		public const uint DEPTH_COMPONENT = 0x1902;
		public const uint DEPTH_COMPONENT16 = 0x81A5;
		public const uint DEPTH_COMPONENT16_SGIX = 0x81A5;
		public const uint DEPTH_COMPONENT24 = 0x81A6;
		public const uint DEPTH_COMPONENT24_SGIX = 0x81A6;
		public const uint DEPTH_COMPONENT32 = 0x81A7;
		public const uint DEPTH_COMPONENT32_SGIX = 0x81A7;
		public const uint DEPTH_FUNC = 0x0B74;
		public const uint DEPTH_RANGE = 0x0B70;
		public const uint DEPTH_SCALE = 0x0D1E;
		public const uint DEPTH_TEST = 0x0B71;
		public const uint DEPTH_TEXTURE_MODE = 0x884B;
		public const uint DEPTH_WRITEMASK = 0x0B72;
		public const uint DIFFUSE = 0x1201;
		public const uint DITHER = 0x0BD0;
		public const uint DOMAIN = 0x0A02;
		public const uint DONT_CARE = 0x1100;
		public const uint DOT3_RGB = 0x86AE;
		public const uint DOT3_RGBA = 0x86AF;
		public const uint DOUBLE = 0x140A;
		public const uint DOUBLE_EXT = 0x140A;
		public const uint DOUBLEBUFFER = 0x0C32;
		public const uint DRAW_BUFFER = 0x0C01;
		public const uint DRAW_PIXEL_TOKEN = 0x0705;
		public const uint DST_ALPHA = 0x0304;
		public const uint DST_COLOR = 0x0306;
		public const uint EDGE_FLAG = 0x0B43;
		public const uint EDGE_FLAG_ARRAY = 0x8079;
		public const uint EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D;
		public const uint EDGE_FLAG_ARRAY_EXT = 0x8079;
		public const uint EDGE_FLAG_ARRAY_POINTER = 0x8093;
		public const uint EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093;
		public const uint EDGE_FLAG_ARRAY_STRIDE = 0x808C;
		public const uint EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C;
		public const uint EMISSION = 0x1600;
		public const uint ENABLE_BIT = 0x00002000;
		public const uint EQUAL = 0x0202;
		public const uint EQUIV = 0x1509;
		public const uint EVAL_BIT = 0x00010000;
		public const uint EXP = 0x0800;
		public const uint EXP2 = 0x0801;
		public const uint EXTENSIONS = 0x1F03;
		public const uint EYE_LINEAR = 0x2400;
		public const uint EYE_PLANE = 0x2502;
		public const uint FALSE = 0;
		public const uint FASTEST = 0x1101;
		public const uint FEEDBACK = 0x1C01;
		public const uint FEEDBACK_BUFFER_POINTER = 0x0DF0;
		public const uint FEEDBACK_BUFFER_SIZE = 0x0DF1;
		public const uint FEEDBACK_BUFFER_TYPE = 0x0DF2;
		public const uint FILL = 0x1B02;
		public const uint FLAT = 0x1D00;
		public const uint FLOAT = 0x1406;
		public const uint FOG = 0x0B60;
		public const uint FOG_BIT = 0x00000080;
		public const uint FOG_COLOR = 0x0B66;
		public const uint FOG_COORDINATE = 0x8451;
		public const uint FOG_COORDINATE_ARRAY = 0x8457;
		public const uint FOG_COORDINATE_ARRAY_POINTER = 0x8456;
		public const uint FOG_COORDINATE_ARRAY_STRIDE = 0x8455;
		public const uint FOG_COORDINATE_ARRAY_TYPE = 0x8454;
		public const uint FOG_COORDINATE_SOURCE = 0x8450;
		public const uint FOG_DENSITY = 0x0B62;
		public const uint FOG_END = 0x0B64;
		public const uint FOG_HINT = 0x0C54;
		public const uint FOG_INDEX = 0x0B61;
		public const uint FOG_MODE = 0x0B65;
		public const uint FOG_START = 0x0B63;
		public const uint FRAGMENT_DEPTH = 0x8452;
		public const uint FRONT = 0x0404;
		public const uint FRONT_AND_BACK = 0x0408;
		public const uint FRONT_FACE = 0x0B46;
		public const uint FRONT_LEFT = 0x0400;
		public const uint FRONT_RIGHT = 0x0401;
		public const uint FUNC_REVERSE_SUBTRACT_EXT = 0x800B;
		public const uint FUNC_SUBTRACT_EXT = 0x800A;
		public const uint GENERATE_MIPMAP = 0x8191;
		public const uint GENERATE_MIPMAP_HINT = 0x8192;
		public const uint GENERATE_MIPMAP_HINT_SGIS = 0x8192;
		public const uint GENERATE_MIPMAP_SGIS = 0x8191;
		public const uint GEQUAL = 0x0206;
		public const uint GREATER = 0x0204;
		public const uint GREEN = 0x1904;
		public const uint GREEN_BIAS = 0x0D19;
		public const uint GREEN_BITS = 0x0D53;
		public const uint GREEN_SCALE = 0x0D18;
		public const uint HINT_BIT = 0x00008000;
		public const uint INCR = 0x1E02;
		public const uint INCR_WRAP = 0x8507;
		public const uint INDEX_ARRAY = 0x8077;
		public const uint INDEX_ARRAY_COUNT_EXT = 0x8087;
		public const uint INDEX_ARRAY_EXT = 0x8077;
		public const uint INDEX_ARRAY_POINTER = 0x8091;
		public const uint INDEX_ARRAY_POINTER_EXT = 0x8091;
		public const uint INDEX_ARRAY_STRIDE = 0x8086;
		public const uint INDEX_ARRAY_STRIDE_EXT = 0x8086;
		public const uint INDEX_ARRAY_TYPE = 0x8085;
		public const uint INDEX_ARRAY_TYPE_EXT = 0x8085;
		public const uint INDEX_BITS = 0x0D51;
		public const uint INDEX_CLEAR_VALUE = 0x0C20;
		public const uint INDEX_LOGIC_OP = 0x0BF1;
		public const uint INDEX_MODE = 0x0C30;
		public const uint INDEX_OFFSET = 0x0D13;
		public const uint INDEX_SHIFT = 0x0D12;
		public const uint INDEX_WRITEMASK = 0x0C21;
		public const uint INT = 0x1404;
		public const uint INTENSITY = 0x8049;
		public const uint INTENSITY12 = 0x804C;
		public const uint INTENSITY16 = 0x804D;
		public const uint INTENSITY4 = 0x804A;
		public const uint INTENSITY8 = 0x804B;
		public const uint INTERPOLATE = 0x8575;
		public const uint INVALID_ENUM = 0x0500;
		public const uint INVALID_OPERATION = 0x0502;
		public const uint INVALID_VALUE = 0x0501;
		public const uint INVERT = 0x150A;
		public const uint KEEP = 0x1E00;
		public const uint LEFT = 0x0406;
		public const uint LEQUAL = 0x0203;
		public const uint LESS = 0x0201;
		public const uint LIGHT_MODEL_AMBIENT = 0x0B53;
		public const uint LIGHT_MODEL_COLOR_CONTROL = 0x81F8;
		public const uint LIGHT_MODEL_LOCAL_VIEWER = 0x0B51;
		public const uint LIGHT_MODEL_TWO_SIDE = 0x0B52;
		public const uint LIGHT0 = 0x4000;
		public const uint LIGHT1 = 0x4001;
		public const uint LIGHT2 = 0x4002;
		public const uint LIGHT3 = 0x4003;
		public const uint LIGHT4 = 0x4004;
		public const uint LIGHT5 = 0x4005;
		public const uint LIGHT6 = 0x4006;
		public const uint LIGHT7 = 0x4007;
		public const uint LIGHTING = 0x0B50;
		public const uint LIGHTING_BIT = 0x00000040;
		public const uint LINE = 0x1B01;
		public const uint LINE_BIT = 0x00000004;
		public const uint LINE_LOOP = 0x0002;
		public const uint LINE_RESET_TOKEN = 0x0707;
		public const uint LINE_SMOOTH = 0x0B20;
		public const uint LINE_SMOOTH_HINT = 0x0C52;
		public const uint LINE_STIPPLE = 0x0B24;
		public const uint LINE_STIPPLE_PATTERN = 0x0B25;
		public const uint LINE_STIPPLE_REPEAT = 0x0B26;
		public const uint LINE_STRIP = 0x0003;
		public const uint LINE_TOKEN = 0x0702;
		public const uint LINE_WIDTH = 0x0B21;
		public const uint LINE_WIDTH_GRANULARITY = 0x0B23;
		public const uint LINE_WIDTH_RANGE = 0x0B22;
		public const int LINEAR = 0x2601;
		public const int LINEAR_ATTENUATION = 0x1208;
		public const int LINEAR_MIPMAP_LINEAR = 0x2703;
		public const int LINEAR_MIPMAP_NEAREST = 0x2701;
		public const uint LINES = 0x0001;
		public const uint LIST_BASE = 0x0B32;
		public const uint LIST_BIT = 0x00020000;
		public const uint LIST_INDEX = 0x0B33;
		public const uint LIST_MODE = 0x0B30;
		public const uint LOAD = 0x0101;
		public const uint LOGIC_OP = 0x0BF1;
		public const uint LOGIC_OP_MODE = 0x0BF0;
		public const uint LUMINANCE = 0x1909;
		public const uint LUMINANCE_ALPHA = 0x190A;
		public const uint LUMINANCE12 = 0x8041;
		public const uint LUMINANCE12_ALPHA12 = 0x8047;
		public const uint LUMINANCE12_ALPHA4 = 0x8046;
		public const uint LUMINANCE16 = 0x8042;
		public const uint LUMINANCE16_ALPHA16 = 0x8048;
		public const uint LUMINANCE4 = 0x803F;
		public const uint LUMINANCE4_ALPHA4 = 0x8043;
		public const uint LUMINANCE6_ALPHA2 = 0x8044;
		public const uint LUMINANCE8 = 0x8040;
		public const uint LUMINANCE8_ALPHA8 = 0x8045;
		public const uint MAP_COLOR = 0x0D10;
		public const uint MAP_STENCIL = 0x0D11;
		public const uint MAP1_COLOR_4 = 0x0D90;
		public const uint MAP1_GRID_DOMAIN = 0x0DD0;
		public const uint MAP1_GRID_SEGMENTS = 0x0DD1;
		public const uint MAP1_INDEX = 0x0D91;
		public const uint MAP1_NORMAL = 0x0D92;
		public const uint MAP1_TEXTURE_COORD_1 = 0x0D93;
		public const uint MAP1_TEXTURE_COORD_2 = 0x0D94;
		public const uint MAP1_TEXTURE_COORD_3 = 0x0D95;
		public const uint MAP1_TEXTURE_COORD_4 = 0x0D96;
		public const uint MAP1_VERTEX_3 = 0x0D97;
		public const uint MAP1_VERTEX_4 = 0x0D98;
		public const uint MAP2_COLOR_4 = 0x0DB0;
		public const uint MAP2_GRID_DOMAIN = 0x0DD2;
		public const uint MAP2_GRID_SEGMENTS = 0x0DD3;
		public const uint MAP2_INDEX = 0x0DB1;
		public const uint MAP2_NORMAL = 0x0DB2;
		public const uint MAP2_TEXTURE_COORD_1 = 0x0DB3;
		public const uint MAP2_TEXTURE_COORD_2 = 0x0DB4;
		public const uint MAP2_TEXTURE_COORD_3 = 0x0DB5;
		public const uint MAP2_TEXTURE_COORD_4 = 0x0DB6;
		public const uint MAP2_VERTEX_3 = 0x0DB7;
		public const uint MAP2_VERTEX_4 = 0x0DB8;
		public const uint MATRIX_MODE = 0x0BA0;
		public const uint MAX_3D_TEXTURE_SIZE = 0x8073;
		public const uint MAX_ATTRIB_STACK_DEPTH = 0x0D35;
		public const uint MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B;
		public const uint MAX_CLIP_PLANES = 0x0D32;
		public const uint MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
		public const uint MAX_ELEMENTS_INDICES = 0x80E9;
		public const uint MAX_ELEMENTS_VERTICES = 0x80E8;
		public const uint MAX_EVAL_ORDER = 0x0D30;
		public const uint MAX_LIGHTS = 0x0D31;
		public const uint MAX_LIST_NESTING = 0x0B31;
		public const uint MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
		public const uint MAX_NAME_STACK_DEPTH = 0x0D37;
		public const uint MAX_PIXEL_MAP_TABLE = 0x0D34;
		public const uint MAX_PROJECTION_STACK_DEPTH = 0x0D38;
		public const uint MAX_TEXTURE_LOD_BIAS = 0x84FD;
		public const uint MAX_TEXTURE_SIZE = 0x0D33;
		public const uint MAX_TEXTURE_STACK_DEPTH = 0x0D39;
		public const uint MAX_TEXTURE_UNITS = 0x84E2;
		public const uint MAX_VIEWPORT_DIMS = 0x0D3A;
		public const uint MIRRORED_REPEAT = 0x8370;
		public const uint MODELVIEW = 0x1700;
		public const uint MODELVIEW_MATRIX = 0x0BA6;
		public const uint MODELVIEW_STACK_DEPTH = 0x0BA3;
		public const uint MODULATE = 0x2100;
		public const uint MULT = 0x0103;
		public const uint MULTISAMPLE = 0x809D;
		public const uint MULTISAMPLE_BIT = 0x20000000;
		public const uint N3F_V3F = 0x2A25;
		public const uint NAME_STACK_DEPTH = 0x0D70;
		public const uint NAND = 0x150E;
		public const int NEAREST = 0x2600;
		public const int NEAREST_MIPMAP_LINEAR = 0x2702;
		public const int NEAREST_MIPMAP_NEAREST = 0x2700;
		public const uint NEVER = 0x0200;
		public const uint NICEST = 0x1102;
		public const uint NO_ERROR = 0;
		public const uint NONE = 0;
		public const uint NOOP = 0x1505;
		public const uint NOR = 0x1508;
		public const uint NORMAL_ARRAY = 0x8075;
		public const uint NORMAL_ARRAY_COUNT_EXT = 0x8080;
		public const uint NORMAL_ARRAY_EXT = 0x8075;
		public const uint NORMAL_ARRAY_POINTER = 0x808F;
		public const uint NORMAL_ARRAY_POINTER_EXT = 0x808F;
		public const uint NORMAL_ARRAY_STRIDE = 0x807F;
		public const uint NORMAL_ARRAY_STRIDE_EXT = 0x807F;
		public const uint NORMAL_ARRAY_TYPE = 0x807E;
		public const uint NORMAL_ARRAY_TYPE_EXT = 0x807E;
		public const uint NORMAL_MAP = 0x8511;
		public const uint NORMALIZE = 0x0BA1;
		public const uint NOTEQUAL = 0x0205;
		public const uint NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
		public const uint OBJECT_LINEAR = 0x2401;
		public const uint OBJECT_PLANE = 0x2501;
		public const uint ONE = 1;
		public const uint ONE_MINUS_DST_ALPHA = 0x0305;
		public const uint ONE_MINUS_DST_COLOR = 0x0307;
		public const uint ONE_MINUS_SRC_ALPHA = 0x0303;
		public const uint ONE_MINUS_SRC_COLOR = 0x0301;
		public const uint OPERAND0_ALPHA = 0x8598;
		public const uint OPERAND0_RGB = 0x8590;
		public const uint OPERAND1_ALPHA = 0x8599;
		public const uint OPERAND1_RGB = 0x8591;
		public const uint OPERAND2_ALPHA = 0x859A;
		public const uint OPERAND2_RGB = 0x8592;
		public const uint OR = 0x1507;
		public const uint OR_INVERTED = 0x150D;
		public const uint OR_REVERSE = 0x150B;
		public const uint ORDER = 0x0A01;
		public const uint OUT_OF_MEMORY = 0x0505;
		public const uint PACK_ALIGNMENT = 0x0D05;
		public const uint PACK_IMAGE_HEIGHT = 0x806C;
		public const uint PACK_LSB_FIRST = 0x0D01;
		public const uint PACK_ROW_LENGTH = 0x0D02;
		public const uint PACK_SKIP_IMAGES = 0x806B;
		public const uint PACK_SKIP_PIXELS = 0x0D04;
		public const uint PACK_SKIP_ROWS = 0x0D03;
		public const uint PACK_SWAP_BYTES = 0x0D00;
		public const uint PASS_THROUGH_TOKEN = 0x0700;
		public const uint PERSPECTIVE_CORRECTION_HINT = 0x0C50;
		public const uint PIXEL_MAP_A_TO_A = 0x0C79;
		public const uint PIXEL_MAP_A_TO_A_SIZE = 0x0CB9;
		public const uint PIXEL_MAP_B_TO_B = 0x0C78;
		public const uint PIXEL_MAP_B_TO_B_SIZE = 0x0CB8;
		public const uint PIXEL_MAP_G_TO_G = 0x0C77;
		public const uint PIXEL_MAP_G_TO_G_SIZE = 0x0CB7;
		public const uint PIXEL_MAP_I_TO_A = 0x0C75;
		public const uint PIXEL_MAP_I_TO_A_SIZE = 0x0CB5;
		public const uint PIXEL_MAP_I_TO_B = 0x0C74;
		public const uint PIXEL_MAP_I_TO_B_SIZE = 0x0CB4;
		public const uint PIXEL_MAP_I_TO_G = 0x0C73;
		public const uint PIXEL_MAP_I_TO_G_SIZE = 0x0CB3;
		public const uint PIXEL_MAP_I_TO_I = 0x0C70;
		public const uint PIXEL_MAP_I_TO_I_SIZE = 0x0CB0;
		public const uint PIXEL_MAP_I_TO_R = 0x0C72;
		public const uint PIXEL_MAP_I_TO_R_SIZE = 0x0CB2;
		public const uint PIXEL_MAP_R_TO_R = 0x0C76;
		public const uint PIXEL_MAP_R_TO_R_SIZE = 0x0CB6;
		public const uint PIXEL_MAP_S_TO_S = 0x0C71;
		public const uint PIXEL_MAP_S_TO_S_SIZE = 0x0CB1;
		public const uint PIXEL_MODE_BIT = 0x00000020;
		public const uint POINT = 0x1B00;
		public const uint POINT_BIT = 0x00000002;
		public const uint POINT_DISTANCE_ATTENUATION = 0x8129;
		public const uint POINT_FADE_THRESHOLD_SIZE = 0x8128;
		public const uint POINT_SIZE = 0x0B11;
		public const uint POINT_SIZE_GRANULARITY = 0x0B13;
		public const uint POINT_SIZE_MAX = 0x8127;
		public const uint POINT_SIZE_MIN = 0x8126;
		public const uint POINT_SIZE_RANGE = 0x0B12;
		public const uint POINT_SMOOTH = 0x0B10;
		public const uint POINT_SMOOTH_HINT = 0x0C51;
		public const uint POINT_TOKEN = 0x0701;
		public const uint POINTS = 0x0000;
		public const uint POLYGON = 0x0009;
		public const uint POLYGON_BIT = 0x00000008;
		public const uint POLYGON_MODE = 0x0B40;
		public const uint POLYGON_OFFSET_FACTOR = 0x8038;
		public const uint POLYGON_OFFSET_FILL = 0x8037;
		public const uint POLYGON_OFFSET_LINE = 0x2A02;
		public const uint POLYGON_OFFSET_POINT = 0x2A01;
		public const uint POLYGON_OFFSET_UNITS = 0x2A00;
		public const uint POLYGON_SMOOTH = 0x0B41;
		public const uint POLYGON_SMOOTH_HINT = 0x0C53;
		public const uint POLYGON_STIPPLE = 0x0B42;
		public const uint POLYGON_STIPPLE_BIT = 0x00000010;
		public const uint POLYGON_TOKEN = 0x0703;
		public const uint POSITION = 0x1203;
		public const uint PREVIOUS = 0x8578;
		public const uint PRIMARY_COLOR = 0x8577;
		public const uint PROJECTION = 0x1701;
		public const uint PROJECTION_MATRIX = 0x0BA7;
		public const uint PROJECTION_STACK_DEPTH = 0x0BA4;
		public const uint PROXY_TEXTURE_1D = 0x8063;
		public const uint PROXY_TEXTURE_2D = 0x8064;
		public const uint PROXY_TEXTURE_3D = 0x8070;
		public const uint PROXY_TEXTURE_CUBE_MAP = 0x851B;
		public const uint Q = 0x2003;
		public const uint QUAD_STRIP = 0x0008;
		public const uint QUADRATIC_ATTENUATION = 0x1209;
		public const uint QUADS = 0x0007;
		public const uint R = 0x2002;
		public const uint R3_G3_B2 = 0x2A10;
		public const uint READ_BUFFER = 0x0C02;
		public const uint RED = 0x1903;
		public const uint RED_BIAS = 0x0D15;
		public const uint RED_BITS = 0x0D52;
		public const uint RED_SCALE = 0x0D14;
		public const uint REFLECTION_MAP = 0x8512;
		public const uint RENDER = 0x1C00;
		public const uint RENDER_MODE = 0x0C40;
		public const uint RENDERER = 0x1F01;
		public const int REPEAT = 0x2901;
		public const uint REPLACE = 0x1E01;
		public const uint RESCALE_NORMAL = 0x803A;
		public const uint RESCALE_NORMAL_EXT = 0x803A;
		public const uint RETURN = 0x0102;
		public const uint RGB = 0x1907;
		public const uint RGB_SCALE = 0x8573;
		public const uint RGB10 = 0x8052;
		public const uint RGB10_A2 = 0x8059;
		public const uint RGB12 = 0x8053;
		public const uint RGB16 = 0x8054;
		public const uint RGB4 = 0x804F;
		public const uint RGB5 = 0x8050;
		public const uint RGB5_A1 = 0x8057;
		public const uint RGB8 = 0x8051;
		public const uint RGBA = 0x1908;
		public const uint RGBA_MODE = 0x0C31;
		public const uint RGBA12 = 0x805A;
		public const uint RGBA16 = 0x805B;
		public const uint RGBA2 = 0x8055;
		public const uint RGBA4 = 0x8056;
		public const uint RGBA8 = 0x8058;
		public const uint RIGHT = 0x0407;
		public const uint S = 0x2000;
		public const uint SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
		public const uint SAMPLE_ALPHA_TO_ONE = 0x809F;
		public const uint SAMPLE_BUFFERS = 0x80A8;
		public const uint SAMPLE_COVERAGE = 0x80A0;
		public const uint SAMPLE_COVERAGE_INVERT = 0x80AB;
		public const uint SAMPLE_COVERAGE_VALUE = 0x80AA;
		public const uint SAMPLES = 0x80A9;
		public const uint SCISSOR_BIT = 0x00080000;
		public const uint SCISSOR_BOX = 0x0C10;
		public const uint SCISSOR_TEST = 0x0C11;
		public const uint SECONDARY_COLOR_ARRAY = 0x845E;
		public const uint SECONDARY_COLOR_ARRAY_POINTER = 0x845D;
		public const uint SECONDARY_COLOR_ARRAY_SIZE = 0x845A;
		public const uint SECONDARY_COLOR_ARRAY_STRIDE = 0x845C;
		public const uint SECONDARY_COLOR_ARRAY_TYPE = 0x845B;
		public const uint SELECT = 0x1C02;
		public const uint SELECTION_BUFFER_POINTER = 0x0DF3;
		public const uint SELECTION_BUFFER_SIZE = 0x0DF4;
		public const uint SEPARATE_SPECULAR_COLOR = 0x81FA;
		public const uint SET = 0x150F;
		public const uint SHADE_MODEL = 0x0B54;
		public const uint SHARED_TEXTURE_PALETTE_EXT = 0x81FB;
		public const uint SHININESS = 0x1601;
		public const uint SHORT = 0x1402;
		public const uint SINGLE_COLOR = 0x81F9;
		public const uint SMOOTH = 0x1D01;
		public const uint SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23;
		public const uint SMOOTH_LINE_WIDTH_RANGE = 0x0B22;
		public const uint SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13;
		public const uint SMOOTH_POINT_SIZE_RANGE = 0x0B12;
		public const uint SOURCE0_ALPHA = 0x8588;
		public const uint SOURCE0_RGB = 0x8580;
		public const uint SOURCE1_ALPHA = 0x8589;
		public const uint SOURCE1_RGB = 0x8581;
		public const uint SOURCE2_ALPHA = 0x858A;
		public const uint SOURCE2_RGB = 0x8582;
		public const uint SPECULAR = 0x1202;
		public const uint SPHERE_MAP = 0x2402;
		public const uint SPOT_CUTOFF = 0x1206;
		public const uint SPOT_DIRECTION = 0x1204;
		public const uint SPOT_EXPONENT = 0x1205;
		public const uint SRC_ALPHA = 0x0302;
		public const uint SRC_ALPHA_SATURATE = 0x0308;
		public const uint SRC_COLOR = 0x0300;
		public const uint STACK_OVERFLOW = 0x0503;
		public const uint STACK_UNDERFLOW = 0x0504;
		public const uint STENCIL = 0x1802;
		public const uint STENCIL_BITS = 0x0D57;
		public const uint STENCIL_BUFFER_BIT = 0x00000400;
		public const uint STENCIL_CLEAR_VALUE = 0x0B91;
		public const uint STENCIL_FAIL = 0x0B94;
		public const uint STENCIL_FUNC = 0x0B92;
		public const uint STENCIL_INDEX = 0x1901;
		public const uint STENCIL_PASS_DEPTH_FAIL = 0x0B95;
		public const uint STENCIL_PASS_DEPTH_PASS = 0x0B96;
		public const uint STENCIL_REF = 0x0B97;
		public const uint STENCIL_TEST = 0x0B90;
		public const uint STENCIL_VALUE_MASK = 0x0B93;
		public const uint STENCIL_WRITEMASK = 0x0B98;
		public const uint STEREO = 0x0C33;
		public const uint SUBPIXEL_BITS = 0x0D50;
		public const uint SUBTRACT = 0x84E7;
		public const uint T = 0x2001;
		public const uint T2F_C3F_V3F = 0x2A2A;
		public const uint T2F_C4F_N3F_V3F = 0x2A2C;
		public const uint T2F_C4UB_V3F = 0x2A29;
		public const uint T2F_N3F_V3F = 0x2A2B;
		public const uint T2F_V3F = 0x2A27;
		public const uint T4F_C4F_N3F_V4F = 0x2A2D;
		public const uint T4F_V4F = 0x2A28;
		public const uint TABLE_TOO_LARGE = 0x8031;
		public const uint TEXTURE = 0x1702;
		public const uint TEXTURE_1D = 0x0DE0;
		public const uint TEXTURE_2D = 0x0DE1;
		public const uint TEXTURE_3D = 0x806F;
		public const uint TEXTURE_ALPHA_SIZE = 0x805F;
		public const uint TEXTURE_BASE_LEVEL = 0x813C;
		public const uint TEXTURE_BASE_LEVEL_SGIS = 0x813C;
		public const uint TEXTURE_BINDING_1D = 0x8068;
		public const uint TEXTURE_BINDING_2D = 0x8069;
		public const uint TEXTURE_BINDING_3D = 0x806A;
		public const uint TEXTURE_BINDING_CUBE_MAP = 0x8514;
		public const uint TEXTURE_BIT = 0x00040000;
		public const uint TEXTURE_BLUE_SIZE = 0x805E;
		public const uint TEXTURE_BORDER = 0x1005;
		public const uint TEXTURE_BORDER_COLOR = 0x1004;
		public const uint TEXTURE_COMPARE_FUNC = 0x884D;
		public const uint TEXTURE_COMPARE_MODE = 0x884C;
		public const uint TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B;
		public const uint TEXTURE_COMPARE_SGIX = 0x819A;
		public const uint TEXTURE_COMPONENTS = 0x1003;
		public const uint TEXTURE_COMPRESSED = 0x86A1;
		public const uint TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0;
		public const uint TEXTURE_COMPRESSION_HINT = 0x84EF;
		public const uint TEXTURE_COORD_ARRAY = 0x8078;
		public const uint TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B;
		public const uint TEXTURE_COORD_ARRAY_EXT = 0x8078;
		public const uint TEXTURE_COORD_ARRAY_POINTER = 0x8092;
		public const uint TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092;
		public const uint TEXTURE_COORD_ARRAY_SIZE = 0x8088;
		public const uint TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088;
		public const uint TEXTURE_COORD_ARRAY_STRIDE = 0x808A;
		public const uint TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A;
		public const uint TEXTURE_COORD_ARRAY_TYPE = 0x8089;
		public const uint TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089;
		public const uint TEXTURE_CUBE_MAP = 0x8513;
		public const uint TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
		public const uint TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
		public const uint TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
		public const uint TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
		public const uint TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
		public const uint TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
		public const uint TEXTURE_DEPTH = 0x8071;
		public const uint TEXTURE_DEPTH_SIZE = 0x884A;
		public const uint TEXTURE_ENV = 0x2300;
		public const uint TEXTURE_ENV_COLOR = 0x2201;
		public const uint TEXTURE_ENV_MODE = 0x2200;
		public const uint TEXTURE_FILTER_CONTROL = 0x8500;
		public const uint TEXTURE_GEN_MODE = 0x2500;
		public const uint TEXTURE_GEN_Q = 0x0C63;
		public const uint TEXTURE_GEN_R = 0x0C62;
		public const uint TEXTURE_GEN_S = 0x0C60;
		public const uint TEXTURE_GEN_T = 0x0C61;
		public const uint TEXTURE_GEQUAL_R_SGIX = 0x819D;
		public const uint TEXTURE_GREEN_SIZE = 0x805D;
		public const uint TEXTURE_HEIGHT = 0x1001;
		public const uint TEXTURE_INTENSITY_SIZE = 0x8061;
		public const uint TEXTURE_INTERNAL_FORMAT = 0x1003;
		public const uint TEXTURE_LEQUAL_R_SGIX = 0x819C;
		public const uint TEXTURE_LOD_BIAS = 0x8501;
		public const uint TEXTURE_LUMINANCE_SIZE = 0x8060;
		public const uint TEXTURE_MAG_FILTER = 0x2800;
		public const uint TEXTURE_MATRIX = 0x0BA8;
		public const uint TEXTURE_MAX_LEVEL = 0x813D;
		public const uint TEXTURE_MAX_LEVEL_SGIS = 0x813D;
		public const uint TEXTURE_MAX_LOD = 0x813B;
		public const uint TEXTURE_MAX_LOD_SGIS = 0x813B;
		public const uint TEXTURE_MIN_FILTER = 0x2801;
		public const uint TEXTURE_MIN_LOD = 0x813A;
		public const uint TEXTURE_MIN_LOD_SGIS = 0x813A;
		public const uint TEXTURE_PRIORITY = 0x8066;
		public const uint TEXTURE_RED_SIZE = 0x805C;
		public const uint TEXTURE_RESIDENT = 0x8067;
		public const uint TEXTURE_STACK_DEPTH = 0x0BA5;
		public const uint TEXTURE_WIDTH = 0x1000;
		public const uint TEXTURE_WRAP_R = 0x8072;
		public const uint TEXTURE_WRAP_S = 0x2802;
		public const uint TEXTURE_WRAP_T = 0x2803;
		public const uint TEXTURE0 = 0x84C0;
		public const uint TEXTURE1 = 0x84C1;
		public const uint TEXTURE10 = 0x84CA;
		public const uint TEXTURE11 = 0x84CB;
		public const uint TEXTURE12 = 0x84CC;
		public const uint TEXTURE13 = 0x84CD;
		public const uint TEXTURE14 = 0x84CE;
		public const uint TEXTURE15 = 0x84CF;
		public const uint TEXTURE16 = 0x84D0;
		public const uint TEXTURE17 = 0x84D1;
		public const uint TEXTURE18 = 0x84D2;
		public const uint TEXTURE19 = 0x84D3;
		public const uint TEXTURE2 = 0x84C2;
		public const uint TEXTURE20 = 0x84D4;
		public const uint TEXTURE21 = 0x84D5;
		public const uint TEXTURE22 = 0x84D6;
		public const uint TEXTURE23 = 0x84D7;
		public const uint TEXTURE24 = 0x84D8;
		public const uint TEXTURE25 = 0x84D9;
		public const uint TEXTURE26 = 0x84DA;
		public const uint TEXTURE27 = 0x84DB;
		public const uint TEXTURE28 = 0x84DC;
		public const uint TEXTURE29 = 0x84DD;
		public const uint TEXTURE3 = 0x84C3;
		public const uint TEXTURE30 = 0x84DE;
		public const uint TEXTURE31 = 0x84DF;
		public const uint TEXTURE4 = 0x84C4;
		public const uint TEXTURE5 = 0x84C5;
		public const uint TEXTURE6 = 0x84C6;
		public const uint TEXTURE7 = 0x84C7;
		public const uint TEXTURE8 = 0x84C8;
		public const uint TEXTURE9 = 0x84C9;
		public const uint TRANSFORM_BIT = 0x00001000;
		public const uint TRANSPOSE_COLOR_MATRIX = 0x84E6;
		public const uint TRANSPOSE_MODELVIEW_MATRIX = 0x84E3;
		public const uint TRANSPOSE_PROJECTION_MATRIX = 0x84E4;
		public const uint TRANSPOSE_TEXTURE_MATRIX = 0x84E5;
		public const uint TRIANGLE_FAN = 0x0006;
		public const uint TRIANGLE_STRIP = 0x0005;
		public const uint TRIANGLES = 0x0004;
		public const uint TRUE = 1;
		public const uint UNPACK_ALIGNMENT = 0x0CF5;
		public const uint UNPACK_IMAGE_HEIGHT = 0x806E;
		public const uint UNPACK_LSB_FIRST = 0x0CF1;
		public const uint UNPACK_ROW_LENGTH = 0x0CF2;
		public const uint UNPACK_SKIP_IMAGES = 0x806D;
		public const uint UNPACK_SKIP_PIXELS = 0x0CF4;
		public const uint UNPACK_SKIP_ROWS = 0x0CF3;
		public const uint UNPACK_SWAP_BYTES = 0x0CF0;
		public const uint UNSIGNED_BYTE = 0x1401;
		public const uint UNSIGNED_BYTE_2_3_3_REV = 0x8362;
		public const uint UNSIGNED_BYTE_3_3_2 = 0x8032;
		public const uint UNSIGNED_BYTE_3_3_2_EXT = 0x8032;
		public const uint UNSIGNED_INT = 0x1405;
		public const uint UNSIGNED_INT_10_10_10_2 = 0x8036;
		public const uint UNSIGNED_INT_10_10_10_2_EXT = 0x8036;
		public const uint UNSIGNED_INT_2_10_10_10_REV = 0x8368;
		public const uint UNSIGNED_INT_8_8_8_8 = 0x8035;
		public const uint UNSIGNED_INT_8_8_8_8_EXT = 0x8035;
		public const uint UNSIGNED_INT_8_8_8_8_REV = 0x8367;
		public const uint UNSIGNED_SHORT = 0x1403;
		public const uint UNSIGNED_SHORT_1_5_5_5_REV = 0x8366;
		public const uint UNSIGNED_SHORT_4_4_4_4 = 0x8033;
		public const uint UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033;
		public const uint UNSIGNED_SHORT_4_4_4_4_REV = 0x8365;
		public const uint UNSIGNED_SHORT_5_5_5_1 = 0x8034;
		public const uint UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034;
		public const uint UNSIGNED_SHORT_5_6_5 = 0x8363;
		public const uint UNSIGNED_SHORT_5_6_5_REV = 0x8364;
		public const uint V2F = 0x2A20;
		public const uint V3F = 0x2A21;
		public const uint VENDOR = 0x1F00;
		public const uint VERSION = 0x1F02;
		public const uint VERSION_1_1 = 1;
		public const uint VERTEX_ARRAY = 0x8074;
		public const uint VERTEX_ARRAY_COUNT_EXT = 0x807D;
		public const uint VERTEX_ARRAY_EXT = 0x8074;
		public const uint VERTEX_ARRAY_POINTER = 0x808E;
		public const uint VERTEX_ARRAY_POINTER_EXT = 0x808E;
		public const uint VERTEX_ARRAY_SIZE = 0x807A;
		public const uint VERTEX_ARRAY_SIZE_EXT = 0x807A;
		public const uint VERTEX_ARRAY_STRIDE = 0x807C;
		public const uint VERTEX_ARRAY_STRIDE_EXT = 0x807C;
		public const uint VERTEX_ARRAY_TYPE = 0x807B;
		public const uint VERTEX_ARRAY_TYPE_EXT = 0x807B;
		public const uint VIEWPORT = 0x0BA2;
		public const uint VIEWPORT_BIT = 0x00000800;
		public const uint XOR = 0x1506;
		public const uint ZERO = 0;
		public const uint ZOOM_X = 0x0D16;
		public const uint ZOOM_Y = 0x0D17;

		[DllImport(GL_DLL, EntryPoint="glAccum"), SuppressUnmanagedCodeSecurity]
		public static extern void Accum(uint op, float _value);

		[DllImport(GL_DLL, EntryPoint="glAlphaFunc"), SuppressUnmanagedCodeSecurity]
		public static extern void AlphaFunc(uint func, float _ref);

		[DllImport(GL_DLL, EntryPoint="glAreTexturesResident"), SuppressUnmanagedCodeSecurity]
		public static extern byte AreTexturesResident(int n, [In] uint[] textures, [In, Out] byte[] residences);

		[DllImport(GL_DLL, EntryPoint="glArrayElement"), SuppressUnmanagedCodeSecurity]
		public static extern void ArrayElement(int i);

		[DllImport(GL_DLL, EntryPoint="glBegin"), SuppressUnmanagedCodeSecurity]
		public static extern void Begin(uint mode);

		[DllImport(GL_DLL, EntryPoint="glBindTexture"), SuppressUnmanagedCodeSecurity]
		public static extern void BindTexture(uint target, uint texture);

		[DllImport(GL_DLL, EntryPoint="glBitmap"), SuppressUnmanagedCodeSecurity]
		public static extern void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, [In] byte[] bitmap);

		[DllImport(GL_DLL, EntryPoint="glBlendFunc"), SuppressUnmanagedCodeSecurity]
		public static extern void BlendFunc(uint sfactor, uint dfactor);

		[DllImport(GL_DLL, EntryPoint="glCallList"), SuppressUnmanagedCodeSecurity]
		public static extern void CallList(uint list);

		[DllImport(GL_DLL, EntryPoint="glCallLists"), SuppressUnmanagedCodeSecurity]
		public static extern void CallLists(int n, uint type, IntPtr lists);

		[DllImport(GL_DLL, EntryPoint="glClear"), SuppressUnmanagedCodeSecurity]
		public static extern void Clear(uint mask);

		[DllImport(GL_DLL, EntryPoint="glClearAccum"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearAccum(float red, float green, float blue, float alpha);

		[DllImport(GL_DLL, EntryPoint="glClearColor"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearColor(float red, float green, float blue, float alpha);

		[DllImport(GL_DLL, EntryPoint="glClearDepth"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearDepth(double depth);

		[DllImport(GL_DLL, EntryPoint="glClearIndex"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearIndex(float c);

		[DllImport(GL_DLL, EntryPoint="glClearStencil"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearStencil(int s);

		[DllImport(GL_DLL, EntryPoint="glClipPlane"), SuppressUnmanagedCodeSecurity]
		public static extern void ClipPlane(uint plane, [In] double[] equation);

		[DllImport(GL_DLL, EntryPoint="glColor3b"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3b(sbyte red, sbyte green, sbyte blue);

		[DllImport(GL_DLL, EntryPoint="glColor3bv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3bv(string v);

		[DllImport(GL_DLL, EntryPoint="glColor3d"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3d(double red, double green, double blue);

		[DllImport(GL_DLL, EntryPoint="glColor3dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3f"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3f(float red, float green, float blue);

		[DllImport(GL_DLL, EntryPoint="glColor3fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3i"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3i(int red, int green, int blue);

		[DllImport(GL_DLL, EntryPoint="glColor3iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3s"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3s(short red, short green, short blue);

		[DllImport(GL_DLL, EntryPoint="glColor3sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3ub"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3ub(byte red, byte green, byte blue);

		[DllImport(GL_DLL, EntryPoint="glColor3ubv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3ubv([In] byte[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3ui"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3ui(uint red, uint green, uint blue);

		[DllImport(GL_DLL, EntryPoint="glColor3uiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3uiv([In] uint[] v);

		[DllImport(GL_DLL, EntryPoint="glColor3us"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3us(ushort red, ushort green, ushort blue);

		[DllImport(GL_DLL, EntryPoint="glColor3usv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color3usv([In] ushort[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4b"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4b(sbyte red, sbyte green, sbyte blue, sbyte alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4bv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4bv(string v);

		[DllImport(GL_DLL, EntryPoint="glColor4d"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4d(double red, double green, double blue, double alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4f"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4f(float red, float green, float blue, float alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4i"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4i(int red, int green, int blue, int alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4s"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4s(short red, short green, short blue, short alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4ub"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4ub(byte red, byte green, byte blue, byte alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4ubv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4ubv([In] byte[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4ui"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4ui(uint red, uint green, uint blue, uint alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4uiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4uiv([In] uint[] v);

		[DllImport(GL_DLL, EntryPoint="glColor4us"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4us(ushort red, ushort green, ushort blue, ushort alpha);

		[DllImport(GL_DLL, EntryPoint="glColor4usv"), SuppressUnmanagedCodeSecurity]
		public static extern void Color4usv([In] ushort[] v);

		[DllImport(GL_DLL, EntryPoint="glColorMask"), SuppressUnmanagedCodeSecurity]
		public static extern void ColorMask(byte red, byte green, byte blue, byte alpha);

		[DllImport(GL_DLL, EntryPoint="glColorMaterial"), SuppressUnmanagedCodeSecurity]
		public static extern void ColorMaterial(uint face, uint mode);

		[DllImport(GL_DLL, EntryPoint="glColorPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void ColorPointer(int size, uint type, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glCopyPixels"), SuppressUnmanagedCodeSecurity]
		public static extern void CopyPixels(int x, int y, int width, int height, uint type);

		[DllImport(GL_DLL, EntryPoint="glCopyTexImage1D"), SuppressUnmanagedCodeSecurity]
		public static extern void CopyTexImage1D(uint target, int level, uint internalFormat, int x, int y, int width, int border);

		[DllImport(GL_DLL, EntryPoint="glCopyTexImage2D"), SuppressUnmanagedCodeSecurity]
		public static extern void CopyTexImage2D(uint target, int level, uint internalFormat, int x, int y, int width, int height, int border);

		[DllImport(GL_DLL, EntryPoint="glCopyTexSubImage1D"), SuppressUnmanagedCodeSecurity]
		public static extern void CopyTexSubImage1D(uint target, int level, int xoffset, int x, int y, int width);

		[DllImport(GL_DLL, EntryPoint="glCopyTexSubImage2D"), SuppressUnmanagedCodeSecurity]
		public static extern void CopyTexSubImage2D(uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height);

		[DllImport(GL_DLL, EntryPoint="glCullFace"), SuppressUnmanagedCodeSecurity]
		public static extern void CullFace(uint mode);

		[DllImport(GL_DLL, EntryPoint="glDeleteLists"), SuppressUnmanagedCodeSecurity]
		public static extern void DeleteLists(uint list, int range);

		[DllImport(GL_DLL, EntryPoint="glDeleteTextures"), SuppressUnmanagedCodeSecurity]
		public static extern void DeleteTextures(int n, [In] uint[] textures);

		[DllImport(GL_DLL, EntryPoint="glDepthFunc"), SuppressUnmanagedCodeSecurity]
		public static extern void DepthFunc(uint func);

		[DllImport(GL_DLL, EntryPoint="glDepthMask"), SuppressUnmanagedCodeSecurity]
		public static extern void DepthMask(byte flag);

		[DllImport(GL_DLL, EntryPoint="glDepthRange"), SuppressUnmanagedCodeSecurity]
		public static extern void DepthRange(double zNear, double zFar);

		[DllImport(GL_DLL, EntryPoint="glDisable"), SuppressUnmanagedCodeSecurity]
		public static extern void Disable(uint cap);

		[DllImport(GL_DLL, EntryPoint="glDisableClientState"), SuppressUnmanagedCodeSecurity]
		public static extern void DisableClientState(uint array);

		[DllImport(GL_DLL, EntryPoint="glDrawArrays"), SuppressUnmanagedCodeSecurity]
		public static extern void DrawArrays(uint mode, int first, int count);

		[DllImport(GL_DLL, EntryPoint="glDrawBuffer"), SuppressUnmanagedCodeSecurity]
		public static extern void DrawBuffer(uint mode);

		[DllImport(GL_DLL, EntryPoint="glDrawElements"), SuppressUnmanagedCodeSecurity]
		public static extern void DrawElements(uint mode, int count, uint type, IntPtr indices);

		[DllImport(GL_DLL, EntryPoint="glDrawPixels"), SuppressUnmanagedCodeSecurity]
		public static extern void DrawPixels(int width, int height, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glEdgeFlag"), SuppressUnmanagedCodeSecurity]
		public static extern void EdgeFlag(byte flag);

		[DllImport(GL_DLL, EntryPoint="glEdgeFlagPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void EdgeFlagPointer(int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glEdgeFlagv"), SuppressUnmanagedCodeSecurity]
		public static extern void EdgeFlagv([In] byte[] flag);

		[DllImport(GL_DLL, EntryPoint="glEnable"), SuppressUnmanagedCodeSecurity]
		public static extern void Enable(uint cap);

		[DllImport(GL_DLL, EntryPoint="glEnableClientState"), SuppressUnmanagedCodeSecurity]
		public static extern void EnableClientState(uint array);

		[DllImport(GL_DLL, EntryPoint="glEnd"), SuppressUnmanagedCodeSecurity]
		public static extern void End();

		[DllImport(GL_DLL, EntryPoint="glEndList"), SuppressUnmanagedCodeSecurity]
		public static extern void EndList();

		[DllImport(GL_DLL, EntryPoint="glEvalCoord1d"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord1d(double u);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord1dv"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord1dv([In] double[] u);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord1f"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord1f(float u);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord1fv"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord1fv([In] float[] u);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord2d"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord2d(double u, double v);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord2dv"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord2dv([In] double[] u);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord2f"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord2f(float u, float v);

		[DllImport(GL_DLL, EntryPoint="glEvalCoord2fv"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalCoord2fv([In] float[] u);

		[DllImport(GL_DLL, EntryPoint="glEvalMesh1"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalMesh1(uint mode, int i1, int i2);

		[DllImport(GL_DLL, EntryPoint="glEvalMesh2"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalMesh2(uint mode, int i1, int i2, int j1, int j2);

		[DllImport(GL_DLL, EntryPoint="glEvalPoint1"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalPoint1(int i);

		[DllImport(GL_DLL, EntryPoint="glEvalPoint2"), SuppressUnmanagedCodeSecurity]
		public static extern void EvalPoint2(int i, int j);

		[DllImport(GL_DLL, EntryPoint="glFeedbackBuffer"), SuppressUnmanagedCodeSecurity]
		public static extern void FeedbackBuffer(int size, uint type, [In, Out] float[] buffer);

		[DllImport(GL_DLL, EntryPoint="glFinish"), SuppressUnmanagedCodeSecurity]
		public static extern void Finish();

		[DllImport(GL_DLL, EntryPoint="glFlush"), SuppressUnmanagedCodeSecurity]
		public static extern void Flush();

		[DllImport(GL_DLL, EntryPoint="glFogf"), SuppressUnmanagedCodeSecurity]
		public static extern void Fogf(uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glFogfv"), SuppressUnmanagedCodeSecurity]
		public static extern void Fogfv(uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glFogi"), SuppressUnmanagedCodeSecurity]
		public static extern void Fogi(uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glFogiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Fogiv(uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glFrontFace"), SuppressUnmanagedCodeSecurity]
		public static extern void FrontFace(uint mode);

		[DllImport(GL_DLL, EntryPoint="glFrustum"), SuppressUnmanagedCodeSecurity]
		public static extern void Frustum(double left, double right, double bottom, double top, double zNear, double zFar);

		[DllImport(GL_DLL, EntryPoint="glGenLists"), SuppressUnmanagedCodeSecurity]
		public static extern uint GenLists(int range);

		[DllImport(GL_DLL, EntryPoint="glGenTextures"), SuppressUnmanagedCodeSecurity]
		public static extern void GenTextures(int n, [In, Out] uint[] textures);

		[DllImport(GL_DLL, EntryPoint="glGetBooleanv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetBooleanv(uint pname, [In, Out] byte[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetClipPlane"), SuppressUnmanagedCodeSecurity]
		public static extern void GetClipPlane(uint plane, [In, Out] double[] equation);

		[DllImport(GL_DLL, EntryPoint="glGetDoublev"), SuppressUnmanagedCodeSecurity]
		public static extern void GetDoublev(uint pname, [In, Out] double[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetError"), SuppressUnmanagedCodeSecurity]
		public static extern uint GetError();

		[DllImport(GL_DLL, EntryPoint="glGetFloatv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetFloatv(uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetIntegerv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetIntegerv(uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetLightfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetLightfv(uint light, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetLightiv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetLightiv(uint light, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetMapdv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetMapdv(uint target, uint query, [In, Out] double[] v);

		[DllImport(GL_DLL, EntryPoint="glGetMapfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetMapfv(uint target, uint query, [In, Out] float[] v);

		[DllImport(GL_DLL, EntryPoint="glGetMapiv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetMapiv(uint target, uint query, [In, Out] int[] v);

		[DllImport(GL_DLL, EntryPoint="glGetMaterialfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetMaterialfv(uint face, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetMaterialiv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetMaterialiv(uint face, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetPixelMapfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetPixelMapfv(uint map, [In, Out] float[] values);

		[DllImport(GL_DLL, EntryPoint="glGetPixelMapuiv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetPixelMapuiv(uint map, [In, Out] uint[] values);

		[DllImport(GL_DLL, EntryPoint="glGetPixelMapusv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetPixelMapusv(uint map, [In, Out] ushort[] values);

		[DllImport(GL_DLL, EntryPoint="glGetPointerv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetPointerv(uint pname, IntPtr /*IntPtr void*/ _params);

		[DllImport(GL_DLL, EntryPoint="glGetPolygonStipple"), SuppressUnmanagedCodeSecurity]
		public static extern void GetPolygonStipple([In, Out] byte[] mask);

		[DllImport(GL_DLL, EntryPoint="glGetString"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*byte*/ GetString(uint name);

		[DllImport(GL_DLL, EntryPoint="glGetTexEnvfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexEnvfv(uint target, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexEnviv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexEnviv(uint target, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexGendv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexGendv(uint coord, uint pname, [In, Out] double[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexGenfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexGenfv(uint coord, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexGeniv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexGeniv(uint coord, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexImage"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexImage(uint target, int level, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glGetTexLevelParameterfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexLevelParameterfv(uint target, int level, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexLevelParameteriv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexLevelParameteriv(uint target, int level, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexParameterfv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexParameterfv(uint target, uint pname, [In, Out] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glGetTexParameteriv"), SuppressUnmanagedCodeSecurity]
		public static extern void GetTexParameteriv(uint target, uint pname, [In, Out] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glHint"), SuppressUnmanagedCodeSecurity]
		public static extern void Hint(uint target, uint mode);

		[DllImport(GL_DLL, EntryPoint="glIndexMask"), SuppressUnmanagedCodeSecurity]
		public static extern void IndexMask(uint mask);

		[DllImport(GL_DLL, EntryPoint="glIndexPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void IndexPointer(uint type, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glIndexd"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexd(double c);

		[DllImport(GL_DLL, EntryPoint="glIndexdv"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexdv([In] double[] c);

		[DllImport(GL_DLL, EntryPoint="glIndexf"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexf(float c);

		[DllImport(GL_DLL, EntryPoint="glIndexfv"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexfv([In] float[] c);

		[DllImport(GL_DLL, EntryPoint="glIndexi"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexi(int c);

		[DllImport(GL_DLL, EntryPoint="glIndexiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexiv([In] int[] c);

		[DllImport(GL_DLL, EntryPoint="glIndexs"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexs(short c);

		[DllImport(GL_DLL, EntryPoint="glIndexsv"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexsv([In] short[] c);

		[DllImport(GL_DLL, EntryPoint="glIndexub"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexub(byte c);

		[DllImport(GL_DLL, EntryPoint="glIndexubv"), SuppressUnmanagedCodeSecurity]
		public static extern void Indexubv([In] byte[] c);

		[DllImport(GL_DLL, EntryPoint="glInitNames"), SuppressUnmanagedCodeSecurity]
		public static extern void InitNames();

		[DllImport(GL_DLL, EntryPoint="glInterleavedArrays"), SuppressUnmanagedCodeSecurity]
		public static extern void InterleavedArrays(uint format, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glIsEnabled"), SuppressUnmanagedCodeSecurity]
		public static extern byte IsEnabled(uint cap);

		[DllImport(GL_DLL, EntryPoint="glIsList"), SuppressUnmanagedCodeSecurity]
		public static extern byte IsList(uint list);

		[DllImport(GL_DLL, EntryPoint="glIsTexture"), SuppressUnmanagedCodeSecurity]
		public static extern byte IsTexture(uint texture);

		[DllImport(GL_DLL, EntryPoint="glLightModelf"), SuppressUnmanagedCodeSecurity]
		public static extern void LightModelf(uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glLightModelfv"), SuppressUnmanagedCodeSecurity]
		public static extern void LightModelfv(uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glLightModeli"), SuppressUnmanagedCodeSecurity]
		public static extern void LightModeli(uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glLightModeliv"), SuppressUnmanagedCodeSecurity]
		public static extern void LightModeliv(uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glLightf"), SuppressUnmanagedCodeSecurity]
		public static extern void Lightf(uint light, uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glLightfv"), SuppressUnmanagedCodeSecurity]
		public static extern void Lightfv(uint light, uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glLighti"), SuppressUnmanagedCodeSecurity]
		public static extern void Lighti(uint light, uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glLightiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Lightiv(uint light, uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glLineStipple"), SuppressUnmanagedCodeSecurity]
		public static extern void LineStipple(int factor, ushort pattern);

		[DllImport(GL_DLL, EntryPoint="glLineWidth"), SuppressUnmanagedCodeSecurity]
		public static extern void LineWidth(float width);

		[DllImport(GL_DLL, EntryPoint="glListBase"), SuppressUnmanagedCodeSecurity]
		public static extern void ListBase(uint _base);

		[DllImport(GL_DLL, EntryPoint="glLoadIdentity"), SuppressUnmanagedCodeSecurity]
		public static extern void LoadIdentity();

		[DllImport(GL_DLL, EntryPoint="glLoadMatrixd"), SuppressUnmanagedCodeSecurity]
		public static extern void LoadMatrixd([In] double[] m);

		[DllImport(GL_DLL, EntryPoint="glLoadMatrixf"), SuppressUnmanagedCodeSecurity]
		public static extern void LoadMatrixf([In] float[] m);

		[DllImport(GL_DLL, EntryPoint="glLoadName"), SuppressUnmanagedCodeSecurity]
		public static extern void LoadName(uint name);

		[DllImport(GL_DLL, EntryPoint="glLogicOp"), SuppressUnmanagedCodeSecurity]
		public static extern void LogicOp(uint opcode);

		[DllImport(GL_DLL, EntryPoint="glMap1d"), SuppressUnmanagedCodeSecurity]
		public static extern void Map1d(uint target, double u1, double u2, int stride, int order, [In] double[] points);

		[DllImport(GL_DLL, EntryPoint="glMap1f"), SuppressUnmanagedCodeSecurity]
		public static extern void Map1f(uint target, float u1, float u2, int stride, int order, [In] float[] points);

		[DllImport(GL_DLL, EntryPoint="glMap2d"), SuppressUnmanagedCodeSecurity]
		public static extern void Map2d(uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, [In] double[] points);

		[DllImport(GL_DLL, EntryPoint="glMap2f"), SuppressUnmanagedCodeSecurity]
		public static extern void Map2f(uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, [In] float[] points);

		[DllImport(GL_DLL, EntryPoint="glMapGrid1d"), SuppressUnmanagedCodeSecurity]
		public static extern void MapGrid1d(int un, double u1, double u2);

		[DllImport(GL_DLL, EntryPoint="glMapGrid1f"), SuppressUnmanagedCodeSecurity]
		public static extern void MapGrid1f(int un, float u1, float u2);

		[DllImport(GL_DLL, EntryPoint="glMapGrid2d"), SuppressUnmanagedCodeSecurity]
		public static extern void MapGrid2d(int un, double u1, double u2, int vn, double v1, double v2);

		[DllImport(GL_DLL, EntryPoint="glMapGrid2f"), SuppressUnmanagedCodeSecurity]
		public static extern void MapGrid2f(int un, float u1, float u2, int vn, float v1, float v2);

		[DllImport(GL_DLL, EntryPoint="glMaterialf"), SuppressUnmanagedCodeSecurity]
		public static extern void Materialf(uint face, uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glMaterialfv"), SuppressUnmanagedCodeSecurity]
		public static extern void Materialfv(uint face, uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glMateriali"), SuppressUnmanagedCodeSecurity]
		public static extern void Materiali(uint face, uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glMaterialiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Materialiv(uint face, uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glMatrixMode"), SuppressUnmanagedCodeSecurity]
		public static extern void MatrixMode(uint mode);

		[DllImport(GL_DLL, EntryPoint="glMultMatrixd"), SuppressUnmanagedCodeSecurity]
		public static extern void MultMatrixd([In] double[] m);

		[DllImport(GL_DLL, EntryPoint="glMultMatrixf"), SuppressUnmanagedCodeSecurity]
		public static extern void MultMatrixf([In] float[] m);

		[DllImport(GL_DLL, EntryPoint="glNewList"), SuppressUnmanagedCodeSecurity]
		public static extern void NewList(uint list, uint mode);

		[DllImport(GL_DLL, EntryPoint="glNormal3b"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3b(sbyte nx, sbyte ny, sbyte nz);

		[DllImport(GL_DLL, EntryPoint="glNormal3bv"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3bv(string v);

		[DllImport(GL_DLL, EntryPoint="glNormal3d"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3d(double nx, double ny, double nz);

		[DllImport(GL_DLL, EntryPoint="glNormal3dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glNormal3f"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3f(float nx, float ny, float nz);

		[DllImport(GL_DLL, EntryPoint="glNormal3fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glNormal3i"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3i(int nx, int ny, int nz);

		[DllImport(GL_DLL, EntryPoint="glNormal3iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glNormal3s"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3s(short nx, short ny, short nz);

		[DllImport(GL_DLL, EntryPoint="glNormal3sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Normal3sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glNormalPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void NormalPointer(uint type, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glOrtho"), SuppressUnmanagedCodeSecurity]
		public static extern void Ortho(double left, double right, double bottom, double top, double zNear, double zFar);

		[DllImport(GL_DLL, EntryPoint="glPassThrough"), SuppressUnmanagedCodeSecurity]
		public static extern void PassThrough(float token);

		[DllImport(GL_DLL, EntryPoint="glPixelMapfv"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelMapfv(uint map, int mapsize, [In] float[] values);

		[DllImport(GL_DLL, EntryPoint="glPixelMapuiv"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelMapuiv(uint map, int mapsize, [In] uint[] values);

		[DllImport(GL_DLL, EntryPoint="glPixelMapusv"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelMapusv(uint map, int mapsize, [In] ushort[] values);

		[DllImport(GL_DLL, EntryPoint="glPixelStoref"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelStoref(uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glPixelStorei"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelStorei(uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glPixelTransferf"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelTransferf(uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glPixelTransferi"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelTransferi(uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glPixelZoom"), SuppressUnmanagedCodeSecurity]
		public static extern void PixelZoom(float xfactor, float yfactor);

		[DllImport(GL_DLL, EntryPoint="glPointSize"), SuppressUnmanagedCodeSecurity]
		public static extern void PointSize(float size);

		[DllImport(GL_DLL, EntryPoint="glPolygonMode"), SuppressUnmanagedCodeSecurity]
		public static extern void PolygonMode(uint face, uint mode);

		[DllImport(GL_DLL, EntryPoint="glPolygonOffset"), SuppressUnmanagedCodeSecurity]
		public static extern void PolygonOffset(float factor, float units);

		[DllImport(GL_DLL, EntryPoint="glPolygonStipple"), SuppressUnmanagedCodeSecurity]
		public static extern void PolygonStipple([In] byte[] mask);

		[DllImport(GL_DLL, EntryPoint="glPopAttrib"), SuppressUnmanagedCodeSecurity]
		public static extern void PopAttrib();

		[DllImport(GL_DLL, EntryPoint="glPopClientAttrib"), SuppressUnmanagedCodeSecurity]
		public static extern void PopClientAttrib();

		[DllImport(GL_DLL, EntryPoint="glPopMatrix"), SuppressUnmanagedCodeSecurity]
		public static extern void PopMatrix();

		[DllImport(GL_DLL, EntryPoint="glPopName"), SuppressUnmanagedCodeSecurity]
		public static extern void PopName();

		[DllImport(GL_DLL, EntryPoint="glPrioritizeTextures"), SuppressUnmanagedCodeSecurity]
		public static extern void PrioritizeTextures(int n, [In] uint[] textures, [In] float[] priorities);

		[DllImport(GL_DLL, EntryPoint="glPushAttrib"), SuppressUnmanagedCodeSecurity]
		public static extern void PushAttrib(uint mask);

		[DllImport(GL_DLL, EntryPoint="glPushClientAttrib"), SuppressUnmanagedCodeSecurity]
		public static extern void PushClientAttrib(uint mask);

		[DllImport(GL_DLL, EntryPoint="glPushMatrix"), SuppressUnmanagedCodeSecurity]
		public static extern void PushMatrix();

		[DllImport(GL_DLL, EntryPoint="glPushName"), SuppressUnmanagedCodeSecurity]
		public static extern void PushName(uint name);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2d"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2d(double x, double y);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2dv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2f"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2f(float x, float y);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2fv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2i"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2i(int x, int y);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2iv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2s"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2s(short x, short y);

		[DllImport(GL_DLL, EntryPoint="glRasterPos2sv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos2sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3d"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3d(double x, double y, double z);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3dv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3f"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3f(float x, float y, float z);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3fv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3i"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3i(int x, int y, int z);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3iv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3s"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3s(short x, short y, short z);

		[DllImport(GL_DLL, EntryPoint="glRasterPos3sv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos3sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4d"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4d(double x, double y, double z, double w);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4dv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4f"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4f(float x, float y, float z, float w);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4fv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4i"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4i(int x, int y, int z, int w);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4iv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4s"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4s(short x, short y, short z, short w);

		[DllImport(GL_DLL, EntryPoint="glRasterPos4sv"), SuppressUnmanagedCodeSecurity]
		public static extern void RasterPos4sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glReadBuffer"), SuppressUnmanagedCodeSecurity]
		public static extern void ReadBuffer(uint mode);

		[DllImport(GL_DLL, EntryPoint="glReadPixels"), SuppressUnmanagedCodeSecurity]
		public static extern void ReadPixels(int x, int y, int width, int height, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glRectd"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectd(double x1, double y1, double x2, double y2);

		[DllImport(GL_DLL, EntryPoint="glRectdv"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectdv([In] double[] v1, [In] double[] v2);

		[DllImport(GL_DLL, EntryPoint="glRectf"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectf(float x1, float y1, float x2, float y2);

		[DllImport(GL_DLL, EntryPoint="glRectfv"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectfv([In] float[] v1, [In] float[] v2);

		[DllImport(GL_DLL, EntryPoint="glRecti"), SuppressUnmanagedCodeSecurity]
		public static extern void Recti(int x1, int y1, int x2, int y2);

		[DllImport(GL_DLL, EntryPoint="glRectiv"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectiv([In] int[] v1, [In] int[] v2);

		[DllImport(GL_DLL, EntryPoint="glRects"), SuppressUnmanagedCodeSecurity]
		public static extern void Rects(short x1, short y1, short x2, short y2);

		[DllImport(GL_DLL, EntryPoint="glRectsv"), SuppressUnmanagedCodeSecurity]
		public static extern void Rectsv([In] short[] v1, [In] short[] v2);

		[DllImport(GL_DLL, EntryPoint="glRenderMode"), SuppressUnmanagedCodeSecurity]
		public static extern int RenderMode(uint mode);

		[DllImport(GL_DLL, EntryPoint="glRotated"), SuppressUnmanagedCodeSecurity]
		public static extern void Rotated(double angle, double x, double y, double z);

		[DllImport(GL_DLL, EntryPoint="glRotatef"), SuppressUnmanagedCodeSecurity]
		public static extern void Rotatef(float angle, float x, float y, float z);

		[DllImport(GL_DLL, EntryPoint="glScaled"), SuppressUnmanagedCodeSecurity]
		public static extern void Scaled(double x, double y, double z);

		[DllImport(GL_DLL, EntryPoint="glScalef"), SuppressUnmanagedCodeSecurity]
		public static extern void Scalef(float x, float y, float z);

		[DllImport(GL_DLL, EntryPoint="glScissor"), SuppressUnmanagedCodeSecurity]
		public static extern void Scissor(int x, int y, int width, int height);

		[DllImport(GL_DLL, EntryPoint="glSelectBuffer"), SuppressUnmanagedCodeSecurity]
		public static extern void SelectBuffer(int size, [In, Out] uint[] buffer);

		[DllImport(GL_DLL, EntryPoint="glShadeModel"), SuppressUnmanagedCodeSecurity]
		public static extern void ShadeModel(uint mode);

		[DllImport(GL_DLL, EntryPoint="glStencilFunc"), SuppressUnmanagedCodeSecurity]
		public static extern void StencilFunc(uint func, int _ref, uint mask);

		[DllImport(GL_DLL, EntryPoint="glStencilMask"), SuppressUnmanagedCodeSecurity]
		public static extern void StencilMask(uint mask);

		[DllImport(GL_DLL, EntryPoint="glStencilOp"), SuppressUnmanagedCodeSecurity]
		public static extern void StencilOp(uint fail, uint zfail, uint zpass);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1d"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1d(double s);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1dv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1f"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1f(float s);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1fv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1i"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1i(int s);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1iv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1s"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1s(short s);

		[DllImport(GL_DLL, EntryPoint="glTexCoord1sv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord1sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2d"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2d(double s, double t);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2dv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2f"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2f(float s, float t);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2fv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2i"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2i(int s, int t);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2iv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2s"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2s(short s, short t);

		[DllImport(GL_DLL, EntryPoint="glTexCoord2sv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord2sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3d"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3d(double s, double t, double r);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3dv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3f"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3f(float s, float t, float r);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3fv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3i"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3i(int s, int t, int r);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3iv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3s"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3s(short s, short t, short r);

		[DllImport(GL_DLL, EntryPoint="glTexCoord3sv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord3sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4d"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4d(double s, double t, double r, double q);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4dv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4f"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4f(float s, float t, float r, float q);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4fv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4i"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4i(int s, int t, int r, int q);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4iv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4s"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4s(short s, short t, short r, short q);

		[DllImport(GL_DLL, EntryPoint="glTexCoord4sv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoord4sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glTexCoordPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void TexCoordPointer(int size, uint type, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glTexEnvf"), SuppressUnmanagedCodeSecurity]
		public static extern void TexEnvf(uint target, uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glTexEnvfv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexEnvfv(uint target, uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexEnvi"), SuppressUnmanagedCodeSecurity]
		public static extern void TexEnvi(uint target, uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glTexEnviv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexEnviv(uint target, uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexGend"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGend(uint coord, uint pname, double param);

		[DllImport(GL_DLL, EntryPoint="glTexGendv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGendv(uint coord, uint pname, [In] double[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexGenf"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGenf(uint coord, uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glTexGenfv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGenfv(uint coord, uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexGeni"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGeni(uint coord, uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glTexGeniv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexGeniv(uint coord, uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexImage1D"), SuppressUnmanagedCodeSecurity]
		public static extern void TexImage1D(uint target, int level, int internalformat, int width, int border, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glTexImage2D"), SuppressUnmanagedCodeSecurity]
		public static extern void TexImage2D(uint target, int level, int internalformat, int width, int height, int border, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glTexParameterf"), SuppressUnmanagedCodeSecurity]
		public static extern void TexParameterf(uint target, uint pname, float param);

		[DllImport(GL_DLL, EntryPoint="glTexParameterfv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexParameterfv(uint target, uint pname, [In] float[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexParameteri"), SuppressUnmanagedCodeSecurity]
		public static extern void TexParameteri(uint target, uint pname, int param);

		[DllImport(GL_DLL, EntryPoint="glTexParameteriv"), SuppressUnmanagedCodeSecurity]
		public static extern void TexParameteriv(uint target, uint pname, [In] int[] _params);

		[DllImport(GL_DLL, EntryPoint="glTexSubImage1D"), SuppressUnmanagedCodeSecurity]
		public static extern void TexSubImage1D(uint target, int level, int xoffset, int width, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glTexSubImage2D"), SuppressUnmanagedCodeSecurity]
		public static extern void TexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, IntPtr pixels);

		[DllImport(GL_DLL, EntryPoint="glTranslated"), SuppressUnmanagedCodeSecurity]
		public static extern void Translated(double x, double y, double z);

		[DllImport(GL_DLL, EntryPoint="glTranslatef"), SuppressUnmanagedCodeSecurity]
		public static extern void Translatef(float x, float y, float z);

		[DllImport(GL_DLL, EntryPoint="glVertex2d"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2d(double x, double y);

		[DllImport(GL_DLL, EntryPoint="glVertex2dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex2f"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2f(float x, float y);

		[DllImport(GL_DLL, EntryPoint="glVertex2fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex2i"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2i(int x, int y);

		[DllImport(GL_DLL, EntryPoint="glVertex2iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex2s"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2s(short x, short y);

		[DllImport(GL_DLL, EntryPoint="glVertex2sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex2sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex3d"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3d(double x, double y, double z);

		[DllImport(GL_DLL, EntryPoint="glVertex3dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex3f"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3f(float x, float y, float z);

		[DllImport(GL_DLL, EntryPoint="glVertex3fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex3i"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3i(int x, int y, int z);

		[DllImport(GL_DLL, EntryPoint="glVertex3iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex3s"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3s(short x, short y, short z);

		[DllImport(GL_DLL, EntryPoint="glVertex3sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex3sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex4d"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4d(double x, double y, double z, double w);

		[DllImport(GL_DLL, EntryPoint="glVertex4dv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4dv([In] double[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex4f"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4f(float x, float y, float z, float w);

		[DllImport(GL_DLL, EntryPoint="glVertex4fv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4fv([In] float[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex4i"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4i(int x, int y, int z, int w);

		[DllImport(GL_DLL, EntryPoint="glVertex4iv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4iv([In] int[] v);

		[DllImport(GL_DLL, EntryPoint="glVertex4s"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4s(short x, short y, short z, short w);

		[DllImport(GL_DLL, EntryPoint="glVertex4sv"), SuppressUnmanagedCodeSecurity]
		public static extern void Vertex4sv([In] short[] v);

		[DllImport(GL_DLL, EntryPoint="glVertexPointer"), SuppressUnmanagedCodeSecurity]
		public static extern void VertexPointer(int size, uint type, int stride, IntPtr pointer);

		[DllImport(GL_DLL, EntryPoint="glViewport"), SuppressUnmanagedCodeSecurity]
		public static extern void Viewport(int x, int y, int width, int height);


	}
}

supertux-openglu.cs

using System;
using System.Runtime.InteropServices;

namespace OpenGlUtil {
    public class glu {
        private const string GLU_DLL = "GLU.dll";

        [DllImport(GLU_DLL, EntryPoint="gluErrorString")]
        private static extern IntPtr _ErrorString(uint error);

        public static string ErrorString(uint error) {
            IntPtr errorstr = _ErrorString(error);
            return Marshal.PtrToStringAuto(errorstr);
        }
    }
}

supertux-sdl.cs

/* WARNING: Automatically generated file */
using System;
using System.Runtime.InteropServices;
using System.Security;


namespace Sdl {
	[StructLayout(LayoutKind.Sequential)]
	public struct RWops {
		public IntPtr /* funcptr */ seek;
		public IntPtr /* funcptr */ read;
		public IntPtr /* funcptr */ write;
		public IntPtr /* funcptr */ close;
		public uint type;
	}





	[StructLayout(LayoutKind.Sequential)]
	public struct _SDL_TimerID {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct AudioSpec {
		public int freq;
		public ushort format;
		public byte channels;
		public byte silence;
		public ushort samples;
		public ushort padding;
		public uint size;
		public IntPtr /* funcptr */ callback;
		public IntPtr /*void*/ userdata;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct AudioCVT {
		public int needed;
		public ushort src_format;
		public ushort dst_format;
		public double rate_incr;
		public IntPtr /*byte*/ buf;
		public int len;
		public int len_cvt;
		public int len_mult;
		public double len_ratio;
		public IntPtr /* funcptr */ filters;
		public int filter_index;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct CDtrack {
		public byte id;
		public byte type;
		public ushort unused;
		public uint length;
		public uint offset;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct CD {
		public int id;
		public CDstatus status;
		public int numtracks;
		public int cur_track;
		public int cur_frame;
		public CDtrack track;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Joystick {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct keysym {
		public byte scancode;
		public Key sym;
		public KMod mod;
		public ushort unicode;
	}




	[StructLayout(LayoutKind.Sequential)]
	public struct Rect {
		public short x;
		public short y;
		public ushort w;
		public ushort h;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Color {
		public byte r;
		public byte g;
		public byte b;
		public byte unused;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Palette {
		public int ncolors;
		public IntPtr /*Color*/ colors;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct PixelFormat {
		public IntPtr /*Palette*/ palette;
		public byte BitsPerPixel;
		public byte BytesPerPixel;
		public byte Rloss;
		public byte Gloss;
		public byte Bloss;
		public byte Aloss;
		public byte Rshift;
		public byte Gshift;
		public byte Bshift;
		public byte Ashift;
		public uint Rmask;
		public uint Gmask;
		public uint Bmask;
		public uint Amask;
		public uint colorkey;
		public byte alpha;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Surface {
		public uint flags;
		public IntPtr /*PixelFormat*/ format;
		public int w;
		public int h;
		public ushort pitch;
		public IntPtr /*void*/ pixels;
		public int offset;
		public IntPtr /*private_hwdata*/ hwdata;
		public Rect clip_rect;
		public uint unused1;
		public uint locked;
		public IntPtr /*BlitMap*/ map;
		public uint format_version;
		public int refcount;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct private_hwdata {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct BlitMap {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct VideoInfo {
		public uint hw_available;
		public uint wm_available;
		public uint UnusedBits1;
		public uint UnusedBits2;
		public uint blit_hw;
		public uint blit_hw_CC;
		public uint blit_hw_A;
		public uint blit_sw;
		public uint blit_sw_CC;
		public uint blit_sw_A;
		public uint blit_fill;
		public uint UnusedBits3;
		public uint video_mem;
		public IntPtr /*PixelFormat*/ vfmt;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Overlay {
		public uint format;
		public int w;
		public int h;
		public int planes;
		public IntPtr /*ushort*/ pitches;
		public IntPtr /*IntPtr byte*/ pixels;
		public IntPtr /*private_yuvhwfuncs*/ hwfuncs;
		public IntPtr /*private_yuvhwdata*/ hwdata;
		public uint hw_overlay;
		public uint UnusedBits;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct private_yuvhwfuncs {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct private_yuvhwdata {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct WMcursor {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Cursor {
		public Rect area;
		public short hot_x;
		public short hot_y;
		public IntPtr /*byte*/ data;
		public IntPtr /*byte*/ mask;
		public IntPtr /*byte*/ save;
		public IntPtr /*WMcursor*/ wm_cursor;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ActiveEvent {
		public byte type;
		public byte gain;
		public byte state;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct KeyboardEvent {
		public byte type;
		public byte which;
		public byte state;
		public keysym keysym;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct MouseMotionEvent {
		public byte type;
		public byte which;
		public byte state;
		public ushort x;
		public ushort y;
		public short xrel;
		public short yrel;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct MouseButtonEvent {
		public byte type;
		public byte which;
		public byte button;
		public byte state;
		public ushort x;
		public ushort y;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct JoyAxisEvent {
		public byte type;
		public byte which;
		public byte axis;
		public short _value;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct JoyBallEvent {
		public byte type;
		public byte which;
		public byte ball;
		public short xrel;
		public short yrel;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct JoyHatEvent {
		public byte type;
		public byte which;
		public byte hat;
		public byte _value;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct JoyButtonEvent {
		public byte type;
		public byte which;
		public byte button;
		public byte state;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ResizeEvent {
		public byte type;
		public int w;
		public int h;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct ExposeEvent {
		public byte type;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct QuitEvent {
		public byte type;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct UserEvent {
		public byte type;
		public int code;
		public IntPtr /*void*/ data1;
		public IntPtr /*void*/ data2;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct SysWMmsg {
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct SysWMEvent {
		public byte type;
		public IntPtr /*SysWMmsg*/ msg;
	}

	[StructLayout(LayoutKind.Explicit)]
	public struct Event {
		[FieldOffset(0)]
		public byte type;
		[FieldOffset(0)]
		public ActiveEvent active;
		[FieldOffset(0)]
		public KeyboardEvent key;
		[FieldOffset(0)]
		public MouseMotionEvent motion;
		[FieldOffset(0)]
		public MouseButtonEvent button;
		[FieldOffset(0)]
		public JoyAxisEvent jaxis;
		[FieldOffset(0)]
		public JoyBallEvent jball;
		[FieldOffset(0)]
		public JoyHatEvent jhat;
		[FieldOffset(0)]
		public JoyButtonEvent jbutton;
		[FieldOffset(0)]
		public ResizeEvent resize;
		[FieldOffset(0)]
		public ExposeEvent expose;
		[FieldOffset(0)]
		public QuitEvent quit;
		[FieldOffset(0)]
		public UserEvent user;
		[FieldOffset(0)]
		public SysWMEvent syswm;
	}

	[StructLayout(LayoutKind.Sequential)]
	public struct Version {
		public byte major;
		public byte minor;
		public byte patch;
	}




	public enum ErrorCode {
		ENOMEM,
		EFREAD,
		EFWRITE,
		EFSEEK,
		LASTERROR,
	}

	public enum AudioStatus {
		STOPPED = 0,
		PLAYING,
		PAUSED,
	}

	public enum CDstatus {
		TRAYEMPTY,
		STOPPED,
		PLAYING,
		PAUSED,
		ERROR = (int) (-1),
	}

	public enum Key {
		UNKNOWN = 0,
		FIRST = 0,
		BACKSPACE = 8,
		TAB = 9,
		CLEAR = 12,
		RETURN = 13,
		PAUSE = 19,
		ESCAPE = 27,
		SPACE = 32,
		EXCLAIM = 33,
		QUOTEDBL = 34,
		HASH = 35,
		DOLLAR = 36,
		AMPERSAND = 38,
		QUOTE = 39,
		LEFTPAREN = 40,
		RIGHTPAREN = 41,
		ASTERISK = 42,
		PLUS = 43,
		COMMA = 44,
		MINUS = 45,
		PERIOD = 46,
		SLASH = 47,
		_0 = 48,
		_1 = 49,
		_2 = 50,
		_3 = 51,
		_4 = 52,
		_5 = 53,
		_6 = 54,
		_7 = 55,
		_8 = 56,
		_9 = 57,
		COLON = 58,
		SEMICOLON = 59,
		LESS = 60,
		EQUALS = 61,
		GREATER = 62,
		QUESTION = 63,
		AT = 64,
		LEFTBRACKET = 91,
		BACKSLASH = 92,
		RIGHTBRACKET = 93,
		CARET = 94,
		UNDERSCORE = 95,
		BACKQUOTE = 96,
		a = 97,
		b = 98,
		c = 99,
		d = 100,
		e = 101,
		f = 102,
		g = 103,
		h = 104,
		i = 105,
		j = 106,
		k = 107,
		l = 108,
		m = 109,
		n = 110,
		o = 111,
		p = 112,
		q = 113,
		r = 114,
		s = 115,
		t = 116,
		u = 117,
		v = 118,
		w = 119,
		x = 120,
		y = 121,
		z = 122,
		DELETE = 127,
		WORLD_0 = 160,
		WORLD_1 = 161,
		WORLD_2 = 162,
		WORLD_3 = 163,
		WORLD_4 = 164,
		WORLD_5 = 165,
		WORLD_6 = 166,
		WORLD_7 = 167,
		WORLD_8 = 168,
		WORLD_9 = 169,
		WORLD_10 = 170,
		WORLD_11 = 171,
		WORLD_12 = 172,
		WORLD_13 = 173,
		WORLD_14 = 174,
		WORLD_15 = 175,
		WORLD_16 = 176,
		WORLD_17 = 177,
		WORLD_18 = 178,
		WORLD_19 = 179,
		WORLD_20 = 180,
		WORLD_21 = 181,
		WORLD_22 = 182,
		WORLD_23 = 183,
		WORLD_24 = 184,
		WORLD_25 = 185,
		WORLD_26 = 186,
		WORLD_27 = 187,
		WORLD_28 = 188,
		WORLD_29 = 189,
		WORLD_30 = 190,
		WORLD_31 = 191,
		WORLD_32 = 192,
		WORLD_33 = 193,
		WORLD_34 = 194,
		WORLD_35 = 195,
		WORLD_36 = 196,
		WORLD_37 = 197,
		WORLD_38 = 198,
		WORLD_39 = 199,
		WORLD_40 = 200,
		WORLD_41 = 201,
		WORLD_42 = 202,
		WORLD_43 = 203,
		WORLD_44 = 204,
		WORLD_45 = 205,
		WORLD_46 = 206,
		WORLD_47 = 207,
		WORLD_48 = 208,
		WORLD_49 = 209,
		WORLD_50 = 210,
		WORLD_51 = 211,
		WORLD_52 = 212,
		WORLD_53 = 213,
		WORLD_54 = 214,
		WORLD_55 = 215,
		WORLD_56 = 216,
		WORLD_57 = 217,
		WORLD_58 = 218,
		WORLD_59 = 219,
		WORLD_60 = 220,
		WORLD_61 = 221,
		WORLD_62 = 222,
		WORLD_63 = 223,
		WORLD_64 = 224,
		WORLD_65 = 225,
		WORLD_66 = 226,
		WORLD_67 = 227,
		WORLD_68 = 228,
		WORLD_69 = 229,
		WORLD_70 = 230,
		WORLD_71 = 231,
		WORLD_72 = 232,
		WORLD_73 = 233,
		WORLD_74 = 234,
		WORLD_75 = 235,
		WORLD_76 = 236,
		WORLD_77 = 237,
		WORLD_78 = 238,
		WORLD_79 = 239,
		WORLD_80 = 240,
		WORLD_81 = 241,
		WORLD_82 = 242,
		WORLD_83 = 243,
		WORLD_84 = 244,
		WORLD_85 = 245,
		WORLD_86 = 246,
		WORLD_87 = 247,
		WORLD_88 = 248,
		WORLD_89 = 249,
		WORLD_90 = 250,
		WORLD_91 = 251,
		WORLD_92 = 252,
		WORLD_93 = 253,
		WORLD_94 = 254,
		WORLD_95 = 255,
		KP0 = 256,
		KP1 = 257,
		KP2 = 258,
		KP3 = 259,
		KP4 = 260,
		KP5 = 261,
		KP6 = 262,
		KP7 = 263,
		KP8 = 264,
		KP9 = 265,
		KP_PERIOD = 266,
		KP_DIVIDE = 267,
		KP_MULTIPLY = 268,
		KP_MINUS = 269,
		KP_PLUS = 270,
		KP_ENTER = 271,
		KP_EQUALS = 272,
		UP = 273,
		DOWN = 274,
		RIGHT = 275,
		LEFT = 276,
		INSERT = 277,
		HOME = 278,
		END = 279,
		PAGEUP = 280,
		PAGEDOWN = 281,
		F1 = 282,
		F2 = 283,
		F3 = 284,
		F4 = 285,
		F5 = 286,
		F6 = 287,
		F7 = 288,
		F8 = 289,
		F9 = 290,
		F10 = 291,
		F11 = 292,
		F12 = 293,
		F13 = 294,
		F14 = 295,
		F15 = 296,
		NUMLOCK = 300,
		CAPSLOCK = 301,
		SCROLLOCK = 302,
		RSHIFT = 303,
		LSHIFT = 304,
		RCTRL = 305,
		LCTRL = 306,
		RALT = 307,
		LALT = 308,
		RMETA = 309,
		LMETA = 310,
		LSUPER = 311,
		RSUPER = 312,
		MODE = 313,
		COMPOSE = 314,
		HELP = 315,
		PRINT = 316,
		SYSREQ = 317,
		BREAK = 318,
		MENU = 319,
		POWER = 320,
		EURO = 321,
		UNDO = 322,
		LAST,
	}

	public enum KMod {
		NONE = 0x0000,
		LSHIFT = 0x0001,
		RSHIFT = 0x0002,
		LCTRL = 0x0040,
		RCTRL = 0x0080,
		LALT = 0x0100,
		RALT = 0x0200,
		LMETA = 0x0400,
		RMETA = 0x0800,
		NUM = 0x1000,
		CAPS = 0x2000,
		MODE = 0x4000,
		RESERVED = 0x8000,
	}

	public enum GLattr {
		RED_SIZE,
		GREEN_SIZE,
		BLUE_SIZE,
		ALPHA_SIZE,
		BUFFER_SIZE,
		DOUBLEBUFFER,
		DEPTH_SIZE,
		STENCIL_SIZE,
		ACCUM_RED_SIZE,
		ACCUM_GREEN_SIZE,
		ACCUM_BLUE_SIZE,
		ACCUM_ALPHA_SIZE,
		STEREO,
		MULTISAMPLEBUFFERS,
		MULTISAMPLESAMPLES,
	}

	public enum GrabMode {
		QUERY = (int) (-1),
		OFF = 0,
		ON = 1,
		FULLSCREEN,
	}



	public enum EventAction {
		ADDEVENT,
		PEEKEVENT,
		GETEVENT,
	}

	public class SDL {

            private const string SDL_DLL = "SDL.dll";
    
		public const uint AUDIO_S16 = 0x8010;
		public const uint AUDIO_S16LSB = 0x8010;
		public const uint AUDIO_S16MSB = 0x9010;
		public const uint AUDIO_S8 = 0x8008;
		public const uint AUDIO_U16 = 0x0010;
		public const uint AUDIO_U16LSB = 0x0010;
		public const uint AUDIO_U16MSB = 0x1010;
		public const uint AUDIO_U8 = 0x0008;
		public const int CD_FPS = 75;
		public const uint ALL_HOTKEYS = 0xFFFFFFFF;
		public const uint ALLEVENTS = 0xFFFFFFFF;
		public const int ALPHA_OPAQUE = 255;
		public const int ALPHA_TRANSPARENT = 0;
		public const uint ANYFORMAT = 0x10000000;
		public const uint APPACTIVE = 0x04;
		public const uint APPINPUTFOCUS = 0x02;
		public const uint APPMOUSEFOCUS = 0x01;
		public const uint ASYNCBLIT = 0x00000004;
		public const uint AUDIO_TRACK = 0x00;
		public const int BIG_ENDIAN = 4321;
		public const int BUTTON_LEFT = 1;
		public const int BUTTON_MIDDLE = 2;
		public const int BUTTON_RIGHT = 3;
		public const int BUTTON_WHEELDOWN = 5;
		public const int BUTTON_WHEELUP = 4;
		public const uint DATA_TRACK = 0x04;
		public const int DEFAULT_REPEAT_DELAY = 500;
		public const int DEFAULT_REPEAT_INTERVAL = 30;
		public const int DISABLE = 0;
		public const uint DOUBLEBUF = 0x40000000;
		public const int ENABLE = 1;
		public const uint FULLSCREEN = 0x80000000;
		public const uint HAT_CENTERED = 0x00;
		public const uint HAT_DOWN = 0x04;
		public const uint HAT_LEFT = 0x08;
		public const uint HAT_RIGHT = 0x02;
		public const uint HAT_UP = 0x01;
		public const uint HWACCEL = 0x00000100;
		public const uint HWPALETTE = 0x20000000;
		public const uint HWSURFACE = 0x00000001;
		public const int IGNORE = 0;
		public const uint INIT_AUDIO = 0x00000010;
		public const uint INIT_CDROM = 0x00000100;
		public const uint INIT_EVENTTHREAD = 0x01000000;
		public const uint INIT_EVERYTHING = 0x0000FFFF;
		public const uint INIT_JOYSTICK = 0x00000200;
		public const uint INIT_NOPARACHUTE = 0x00100000;
		public const uint INIT_TIMER = 0x00000001;
		public const uint INIT_VIDEO = 0x00000020;
		public const uint IYUV_OVERLAY = 0x56555949;
		public const int LIL_ENDIAN = 1234;
		public const uint LOGPAL = 0x01;
		public const int MAJOR_VERSION = 1;
		public const int MAX_TRACKS = 99;
		public const int MINOR_VERSION = 2;
		public const int MIX_MAXVOLUME = 128;
		public const int MUTEX_TIMEDOUT = 1;
		public const uint NOFRAME = 0x00000020;
		public const uint OPENGL = 0x00000002;
		public const uint OPENGLBLIT = 0x0000000A;
		public const int PATCHLEVEL = 8;
		public const uint PHYSPAL = 0x02;
		public const uint PREALLOC = 0x01000000;
		public const int QUERY = -1;
		public const uint RESIZABLE = 0x00000010;
		public const uint RLEACCEL = 0x00004000;
		public const uint RLEACCELOK = 0x00002000;
		public const uint SRCALPHA = 0x00010000;
		public const uint SRCCOLORKEY = 0x00001000;
		public const uint SWSURFACE = 0x00000000;
		public const int TIMESLICE = 10;
		public const uint UYVY_OVERLAY = 0x59565955;
		public const uint YUY2_OVERLAY = 0x32595559;
		public const uint YV12_OVERLAY = 0x32315659;
		public const uint YVYU_OVERLAY = 0x55595659;
		public const int TIMER_RESOLUTION = 10;
		public const int PRESSED = 0x01;
		public const int RELEASED = 0x00;
		public const int NOEVENT = 0;
		public const int ACTIVEEVENT = 1;
		public const int KEYDOWN = 2;
		public const int KEYUP = 3;
		public const int MOUSEMOTION = 4;
		public const int MOUSEBUTTONDOWN = 5;
		public const int MOUSEBUTTONUP = 6;
		public const int JOYAXISMOTION = 7;
		public const int JOYBALLMOTION = 8;
		public const int JOYHATMOTION = 9;
		public const int JOYBUTTONDOWN = 10;
		public const int JOYBUTTONUP = 11;
		public const int QUIT = 12;
		public const int SYSWMEVENT = 13;
		public const int EVENT_RESERVEDA = 14;
		public const int EVENT_RESERVEDB = 15;
		public const int VIDEORESIZE = 16;
		public const int VIDEOEXPOSE = 17;
		public const int EVENT_RESERVED2 = 18;
		public const int EVENT_RESERVED3 = 19;
		public const int EVENT_RESERVED4 = 20;
		public const int EVENT_RESERVED5 = 21;
		public const int EVENT_RESERVED6 = 22;
		public const int EVENT_RESERVED7 = 23;
		public const int USEREVENT = 24;
		public const int NUMEVENTS = 32;
		public const int ACTIVEEVENTMASK = (int) (1 << ACTIVEEVENT);
		public const int KEYDOWNMASK = (int) (1 << KEYDOWN);
		public const int KEYUPMASK = (int) (1 << KEYUP);
		public const int MOUSEMOTIONMASK = (int) (1 << MOUSEMOTION);
		public const int MOUSEBUTTONDOWNMASK = (int) (1 << MOUSEBUTTONDOWN);
		public const int MOUSEBUTTONUPMASK = (int) (1 << MOUSEBUTTONUP);
		public const int MOUSEEVENTMASK = (int) (1 << MOUSEMOTION | 1 << MOUSEBUTTONDOWN | 1 << MOUSEBUTTONUP);
		public const int JOYAXISMOTIONMASK = (int) (1 << JOYAXISMOTION);
		public const int JOYBALLMOTIONMASK = (int) (1 << JOYBALLMOTION);
		public const int JOYHATMOTIONMASK = (int) (1 << JOYHATMOTION);
		public const int JOYBUTTONDOWNMASK = (int) (1 << JOYBUTTONDOWN);
		public const int JOYBUTTONUPMASK = (int) (1 << JOYBUTTONUP);
		public const int JOYEVENTMASK = (int) (1 << JOYAXISMOTION | 1 << JOYBALLMOTION | 1 << JOYHATMOTION | 1 << JOYBUTTONDOWN | 1 << JOYBUTTONUP);
		public const int VIDEORESIZEMASK = (int) (1 << VIDEORESIZE);
		public const int VIDEOEXPOSEMASK = (int) (1 << VIDEOEXPOSE);
		public const int QUITMASK = (int) (1 << QUIT);
		public const int SYSWMEVENTMASK = (int) (1 << SYSWMEVENT);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetError"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ _GetError();

		[DllImport(SDL_DLL, EntryPoint="SDL_ClearError"), SuppressUnmanagedCodeSecurity]
		public static extern void ClearError();

		[DllImport(SDL_DLL, EntryPoint="SDL_Error"), SuppressUnmanagedCodeSecurity]
		public static extern void Error(ErrorCode code);

		[DllImport(SDL_DLL, EntryPoint="SDL_RWFromFile"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*RWops*/ RWFromFile(string file, string mode);

		[DllImport(SDL_DLL, EntryPoint="SDL_RWFromMem"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*RWops*/ RWFromMem(IntPtr mem, int size);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetTicks"), SuppressUnmanagedCodeSecurity]
		public static extern uint GetTicks();

		[DllImport(SDL_DLL, EntryPoint="SDL_Delay"), SuppressUnmanagedCodeSecurity]
		public static extern void Delay(uint ms);

		[DllImport(SDL_DLL, EntryPoint="SDL_AudioInit"), SuppressUnmanagedCodeSecurity]
		public static extern int AudioInit(string driver_name);

		[DllImport(SDL_DLL, EntryPoint="SDL_AudioQuit"), SuppressUnmanagedCodeSecurity]
		public static extern void AudioQuit();

		[DllImport(SDL_DLL, EntryPoint="SDL_AudioDriverName"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ AudioDriverName([In, Out] sbyte[] namebuf, int maxlen);

		[DllImport(SDL_DLL, EntryPoint="SDL_OpenAudio"), SuppressUnmanagedCodeSecurity]
		public static extern int OpenAudio(ref AudioSpec desired, ref AudioSpec obtained);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetAudioStatus"), SuppressUnmanagedCodeSecurity]
		public static extern AudioStatus GetAudioStatus();

		[DllImport(SDL_DLL, EntryPoint="SDL_PauseAudio"), SuppressUnmanagedCodeSecurity]
		public static extern void PauseAudio(int pause_on);

		[DllImport(SDL_DLL, EntryPoint="SDL_FreeWAV"), SuppressUnmanagedCodeSecurity]
		public static extern void FreeWAV([In, Out] byte[] audio_buf);

		[DllImport(SDL_DLL, EntryPoint="SDL_BuildAudioCVT"), SuppressUnmanagedCodeSecurity]
		public static extern int BuildAudioCVT(ref AudioCVT cvt, ushort src_format, byte src_channels, int src_rate, ushort dst_format, byte dst_channels, int dst_rate);

		[DllImport(SDL_DLL, EntryPoint="SDL_ConvertAudio"), SuppressUnmanagedCodeSecurity]
		public static extern int ConvertAudio(ref AudioCVT cvt);

		[DllImport(SDL_DLL, EntryPoint="SDL_MixAudio"), SuppressUnmanagedCodeSecurity]
		public static extern void MixAudio([In, Out] byte[] dst, [In] byte[] src, uint len, int volume);

		[DllImport(SDL_DLL, EntryPoint="SDL_LockAudio"), SuppressUnmanagedCodeSecurity]
		public static extern void LockAudio();

		[DllImport(SDL_DLL, EntryPoint="SDL_UnlockAudio"), SuppressUnmanagedCodeSecurity]
		public static extern void UnlockAudio();

		[DllImport(SDL_DLL, EntryPoint="SDL_CloseAudio"), SuppressUnmanagedCodeSecurity]
		public static extern void CloseAudio();

		[DllImport(SDL_DLL, EntryPoint="SDL_CDNumDrives"), SuppressUnmanagedCodeSecurity]
		public static extern int CDNumDrives();

		[DllImport(SDL_DLL, EntryPoint="SDL_CDName"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ CDName(int drive);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDOpen"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*CD*/ CDOpen(int drive);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDStatus"), SuppressUnmanagedCodeSecurity]
		public static extern CDstatus CDStatus(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDPlayTracks"), SuppressUnmanagedCodeSecurity]
		public static extern int CDPlayTracks(IntPtr /*CD*/ cdrom, int start_track, int start_frame, int ntracks, int nframes);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDPlay"), SuppressUnmanagedCodeSecurity]
		public static extern int CDPlay(IntPtr /*CD*/ cdrom, int start, int length);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDPause"), SuppressUnmanagedCodeSecurity]
		public static extern int CDPause(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDResume"), SuppressUnmanagedCodeSecurity]
		public static extern int CDResume(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDStop"), SuppressUnmanagedCodeSecurity]
		public static extern int CDStop(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDEject"), SuppressUnmanagedCodeSecurity]
		public static extern int CDEject(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_CDClose"), SuppressUnmanagedCodeSecurity]
		public static extern void CDClose(IntPtr /*CD*/ cdrom);

		[DllImport(SDL_DLL, EntryPoint="SDL_NumJoysticks"), SuppressUnmanagedCodeSecurity]
		public static extern int NumJoysticks();

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickName"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ JoystickName(int device_index);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickOpen"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Joystick*/ JoystickOpen(int device_index);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickOpened"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickOpened(int device_index);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickIndex"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickIndex(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickNumAxes"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickNumAxes(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickNumBalls"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickNumBalls(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickNumHats"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickNumHats(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickNumButtons"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickNumButtons(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickUpdate"), SuppressUnmanagedCodeSecurity]
		public static extern void JoystickUpdate();

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickEventState"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickEventState(int state);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickGetAxis"), SuppressUnmanagedCodeSecurity]
		public static extern short JoystickGetAxis(IntPtr /*Joystick*/ joystick, int axis);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickGetHat"), SuppressUnmanagedCodeSecurity]
		public static extern byte JoystickGetHat(IntPtr /*Joystick*/ joystick, int hat);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickGetBall"), SuppressUnmanagedCodeSecurity]
		public static extern int JoystickGetBall(IntPtr /*Joystick*/ joystick, int ball, [In, Out] int[] dx, [In, Out] int[] dy);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickGetButton"), SuppressUnmanagedCodeSecurity]
		public static extern byte JoystickGetButton(IntPtr /*Joystick*/ joystick, int button);

		[DllImport(SDL_DLL, EntryPoint="SDL_JoystickClose"), SuppressUnmanagedCodeSecurity]
		public static extern void JoystickClose(IntPtr /*Joystick*/ joystick);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetAppState"), SuppressUnmanagedCodeSecurity]
		public static extern byte GetAppState();

		[DllImport(SDL_DLL, EntryPoint="SDL_EnableUNICODE"), SuppressUnmanagedCodeSecurity]
		public static extern int EnableUNICODE(bool enable);

		[DllImport(SDL_DLL, EntryPoint="SDL_EnableKeyRepeat"), SuppressUnmanagedCodeSecurity]
		public static extern int EnableKeyRepeat(int delay, int interval);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetKeyState"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*byte*/ GetKeyState([In, Out] int[] numkeys);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetModState"), SuppressUnmanagedCodeSecurity]
		public static extern KMod GetModState();

		[DllImport(SDL_DLL, EntryPoint="SDL_SetModState"), SuppressUnmanagedCodeSecurity]
		public static extern void SetModState(KMod modstate);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetKeyName"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ GetKeyName(Key key);

		[DllImport(SDL_DLL, EntryPoint="SDL_VideoInit"), SuppressUnmanagedCodeSecurity]
		public static extern int VideoInit(string driver_name, uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_VideoQuit"), SuppressUnmanagedCodeSecurity]
		public static extern void VideoQuit();

		[DllImport(SDL_DLL, EntryPoint="SDL_VideoDriverName"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*sbyte*/ VideoDriverName([In, Out] sbyte[] namebuf, int maxlen);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetVideoSurface"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ GetVideoSurface();

		[DllImport(SDL_DLL, EntryPoint="SDL_GetVideoInfo"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*VideoInfo*/ GetVideoInfo();

		[DllImport(SDL_DLL, EntryPoint="SDL_VideoModeOK"), SuppressUnmanagedCodeSecurity]
		public static extern int VideoModeOK(int width, int height, int bpp, uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_ListModes"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*IntPtr Rect*/ ListModes(ref PixelFormat format, uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetVideoMode"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ SetVideoMode(int width, int height, int bpp, uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_UpdateRects"), SuppressUnmanagedCodeSecurity]
		public static extern void UpdateRects(IntPtr /*Surface*/ screen, int numrects, ref Rect rects);

		[DllImport(SDL_DLL, EntryPoint="SDL_UpdateRect"), SuppressUnmanagedCodeSecurity]
		public static extern void UpdateRect(IntPtr /*Surface*/ screen, int x, int y, uint w, uint h);

		[DllImport(SDL_DLL, EntryPoint="SDL_Flip"), SuppressUnmanagedCodeSecurity]
		public static extern int Flip(IntPtr /*Surface*/ screen);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetGamma"), SuppressUnmanagedCodeSecurity]
		public static extern int SetGamma(float red, float green, float blue);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetGammaRamp"), SuppressUnmanagedCodeSecurity]
		public static extern int SetGammaRamp([In] ushort[] red, [In] ushort[] green, [In] ushort[] blue);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetGammaRamp"), SuppressUnmanagedCodeSecurity]
		public static extern int GetGammaRamp([In, Out] ushort[] red, [In, Out] ushort[] green, [In, Out] ushort[] blue);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetColors"), SuppressUnmanagedCodeSecurity]
		public static extern int SetColors(IntPtr /*Surface*/ surface, ref Color colors, int firstcolor, int ncolors);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetPalette"), SuppressUnmanagedCodeSecurity]
		public static extern int SetPalette(IntPtr /*Surface*/ surface, int flags, ref Color colors, int firstcolor, int ncolors);

		[DllImport(SDL_DLL, EntryPoint="SDL_MapRGB"), SuppressUnmanagedCodeSecurity]
		public static extern uint MapRGB(ref PixelFormat format, byte r, byte g, byte b);

		[DllImport(SDL_DLL, EntryPoint="SDL_MapRGBA"), SuppressUnmanagedCodeSecurity]
		public static extern uint MapRGBA(ref PixelFormat format, byte r, byte g, byte b, byte a);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetRGB"), SuppressUnmanagedCodeSecurity]
		public static extern void GetRGB(uint pixel, ref PixelFormat fmt, [In, Out] byte[] r, [In, Out] byte[] g, [In, Out] byte[] b);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetRGBA"), SuppressUnmanagedCodeSecurity]
		public static extern void GetRGBA(uint pixel, ref PixelFormat fmt, [In, Out] byte[] r, [In, Out] byte[] g, [In, Out] byte[] b, [In, Out] byte[] a);

		[DllImport(SDL_DLL, EntryPoint="SDL_CreateRGBSurface"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ CreateRGBSurface(uint flags, int width, int height, int depth, uint Rmask, uint Gmask, uint Bmask, uint Amask);

		[DllImport(SDL_DLL, EntryPoint="SDL_CreateRGBSurfaceFrom"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ CreateRGBSurfaceFrom(IntPtr pixels, int width, int height, int depth, int pitch, uint Rmask, uint Gmask, uint Bmask, uint Amask);

		[DllImport(SDL_DLL, EntryPoint="SDL_FreeSurface"), SuppressUnmanagedCodeSecurity]
		public static extern void FreeSurface(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_LockSurface"), SuppressUnmanagedCodeSecurity]
		public static extern int LockSurface(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_UnlockSurface"), SuppressUnmanagedCodeSecurity]
		public static extern void UnlockSurface(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_LoadBMP_RW"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ LoadBMP_RW(ref RWops src, int freesrc);

		[DllImport(SDL_DLL, EntryPoint="SDL_SaveBMP_RW"), SuppressUnmanagedCodeSecurity]
		public static extern int SaveBMP_RW(IntPtr /*Surface*/ surface, ref RWops dst, int freedst);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetColorKey"), SuppressUnmanagedCodeSecurity]
		public static extern int SetColorKey(IntPtr /*Surface*/ surface, uint flag, uint key);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetAlpha"), SuppressUnmanagedCodeSecurity]
		public static extern int SetAlpha(IntPtr /*Surface*/ surface, uint flag, byte alpha);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetClipRect"), SuppressUnmanagedCodeSecurity]
		public static extern bool SetClipRect(IntPtr /*Surface*/ surface, Rect rect);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetClipRect"), SuppressUnmanagedCodeSecurity]
		public static extern void GetClipRect(IntPtr /*Surface*/ surface, out Rect rect);

		[DllImport(SDL_DLL, EntryPoint="SDL_ConvertSurface"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ ConvertSurface(IntPtr /*Surface*/ src, ref PixelFormat fmt, uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_UpperBlit"), SuppressUnmanagedCodeSecurity]
		public static extern int BlitSurface(IntPtr /*Surface*/ src, IntPtr /*Rect*/ srcrect, IntPtr /*Surface*/ dst, IntPtr /*Rect*/ dstrect);

		[DllImport(SDL_DLL, EntryPoint="SDL_LowerBlit"), SuppressUnmanagedCodeSecurity]
		public static extern int LowerBlit(IntPtr /*Surface*/ src, IntPtr /*Rect*/ srcrect, IntPtr /*Surface*/ dst, IntPtr /*Rect*/ dstrect);

		[DllImport(SDL_DLL, EntryPoint="SDL_FillRect"), SuppressUnmanagedCodeSecurity]
		public static extern int FillRect(IntPtr /*Surface*/ dst, Rect dstrect, uint color);

		[DllImport(SDL_DLL, EntryPoint="SDL_DisplayFormat"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ DisplayFormat(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_DisplayFormatAlpha"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Surface*/ DisplayFormatAlpha(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_CreateYUVOverlay"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Overlay*/ CreateYUVOverlay(int width, int height, uint format, IntPtr /*Surface*/ display);

		[DllImport(SDL_DLL, EntryPoint="SDL_LockYUVOverlay"), SuppressUnmanagedCodeSecurity]
		public static extern int LockYUVOverlay(ref Overlay overlay);

		[DllImport(SDL_DLL, EntryPoint="SDL_UnlockYUVOverlay"), SuppressUnmanagedCodeSecurity]
		public static extern void UnlockYUVOverlay(ref Overlay overlay);

		[DllImport(SDL_DLL, EntryPoint="SDL_DisplayYUVOverlay"), SuppressUnmanagedCodeSecurity]
		public static extern int DisplayYUVOverlay(ref Overlay overlay, Rect dstrect);

		[DllImport(SDL_DLL, EntryPoint="SDL_FreeYUVOverlay"), SuppressUnmanagedCodeSecurity]
		public static extern void FreeYUVOverlay(ref Overlay overlay);

		[DllImport(SDL_DLL, EntryPoint="SDL_GL_LoadLibrary"), SuppressUnmanagedCodeSecurity]
		public static extern int GL_LoadLibrary(string path);

		[DllImport(SDL_DLL, EntryPoint="SDL_GL_SetAttribute"), SuppressUnmanagedCodeSecurity]
		public static extern int GL_SetAttribute(GLattr attr, int _value);

		[DllImport(SDL_DLL, EntryPoint="SDL_GL_GetAttribute"), SuppressUnmanagedCodeSecurity]
		public static extern int GL_GetAttribute(GLattr attr, [In, Out] int[] _value);

		[DllImport(SDL_DLL, EntryPoint="SDL_GL_SwapBuffers"), SuppressUnmanagedCodeSecurity]
		public static extern void GL_SwapBuffers();

		[DllImport(SDL_DLL, EntryPoint="SDL_WM_SetCaption"), SuppressUnmanagedCodeSecurity]
		public static extern void WM_SetCaption(string title, string icon);

		[DllImport(SDL_DLL, EntryPoint="SDL_WM_GetCaption"), SuppressUnmanagedCodeSecurity]
		public static extern void WM_GetCaption(IntPtr /*IntPtr sbyte*/ title, IntPtr /*IntPtr sbyte*/ icon);

		[DllImport(SDL_DLL, EntryPoint="SDL_WM_IconifyWindow"), SuppressUnmanagedCodeSecurity]
		public static extern int WM_IconifyWindow();

		[DllImport(SDL_DLL, EntryPoint="SDL_WM_ToggleFullScreen"), SuppressUnmanagedCodeSecurity]
		public static extern int WM_ToggleFullScreen(IntPtr /*Surface*/ surface);

		[DllImport(SDL_DLL, EntryPoint="SDL_WM_GrabInput"), SuppressUnmanagedCodeSecurity]
		public static extern GrabMode WM_GrabInput(GrabMode mode);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetMouseState"), SuppressUnmanagedCodeSecurity]
		public static extern byte GetMouseState([In, Out] int[] x, [In, Out] int[] y);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetRelativeMouseState"), SuppressUnmanagedCodeSecurity]
		public static extern byte GetRelativeMouseState([In, Out] int[] x, [In, Out] int[] y);

		[DllImport(SDL_DLL, EntryPoint="SDL_WarpMouse"), SuppressUnmanagedCodeSecurity]
		public static extern void WarpMouse(ushort x, ushort y);

		[DllImport(SDL_DLL, EntryPoint="SDL_CreateCursor"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Cursor*/ CreateCursor([In, Out] byte[] data, [In, Out] byte[] mask, int w, int h, int hot_x, int hot_y);

		[DllImport(SDL_DLL, EntryPoint="SDL_SetCursor"), SuppressUnmanagedCodeSecurity]
		public static extern void SetCursor(IntPtr /*Cursor*/ cursor);

		[DllImport(SDL_DLL, EntryPoint="SDL_GetCursor"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Cursor*/ GetCursor();

		[DllImport(SDL_DLL, EntryPoint="SDL_FreeCursor"), SuppressUnmanagedCodeSecurity]
		public static extern void FreeCursor(IntPtr /*Cursor*/ cursor);

		[DllImport(SDL_DLL, EntryPoint="SDL_ShowCursor"), SuppressUnmanagedCodeSecurity]
		public static extern int ShowCursor(int toggle);

		[DllImport(SDL_DLL, EntryPoint="SDL_PumpEvents"), SuppressUnmanagedCodeSecurity]
		public static extern void PumpEvents();

		[DllImport(SDL_DLL, EntryPoint="SDL_PeepEvents"), SuppressUnmanagedCodeSecurity]
		public static extern int PeepEvents([Out] Event[] events, int numevents, EventAction action, uint mask);

		[DllImport(SDL_DLL, EntryPoint="SDL_PollEvent"), SuppressUnmanagedCodeSecurity]
		public static extern int PollEvent(out Event _event);

		[DllImport(SDL_DLL, EntryPoint="SDL_WaitEvent"), SuppressUnmanagedCodeSecurity]
		public static extern int WaitEvent(out Event _event);

		[DllImport(SDL_DLL, EntryPoint="SDL_PushEvent"), SuppressUnmanagedCodeSecurity]
		public static extern int PushEvent(Event _event);

		[DllImport(SDL_DLL, EntryPoint="SDL_EventState"), SuppressUnmanagedCodeSecurity]
		public static extern byte EventState(byte type, int state);

		[DllImport(SDL_DLL, EntryPoint="SDL_Linked_Version"), SuppressUnmanagedCodeSecurity]
		public static extern IntPtr /*Version*/ Linked_Version();

		[DllImport(SDL_DLL, EntryPoint="SDL_Init"), SuppressUnmanagedCodeSecurity]
		public static extern int Init(uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_InitSubSystem"), SuppressUnmanagedCodeSecurity]
		public static extern int InitSubSystem(uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_QuitSubSystem"), SuppressUnmanagedCodeSecurity]
		public static extern void QuitSubSystem(uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_WasInit"), SuppressUnmanagedCodeSecurity]
		public static extern uint WasInit(uint flags);

		[DllImport(SDL_DLL, EntryPoint="SDL_Quit"), SuppressUnmanagedCodeSecurity]
		public static extern void Quit();


                [DllImport(SDL_DLL, EntryPoint="SDL_WM_SetIcon")]
                public static extern void WM_SetIcon(IntPtr icon, IntPtr mask);
    
                public static string GetError() {
                    return Marshal.PtrToStringAuto(_GetError());
                }
    
	}
}