public static void Get(GetPName pname, [Out] float[] data)
		{
			unsafe {
				fixed (float* p_data = data)
				{
					Debug.Assert(Delegates.pglGetFloatv != null, "pglGetFloatv not implemented");
					Delegates.pglGetFloatv((Int32)pname, p_data);
					CallLog("glGetFloatv({0}, {1})", pname, data);
				}
			}
			DebugCheckErrors();
		}

 public static double GetGLInfoDouble(GetPName name)
 {
     double res;
     GL.GetDouble(name, out res);
     return res;
 }

 public static void GetFloat(GetPName pname, out Matrix4 matrix)
 {
     unsafe
     {
         fixed (Matrix4* ptr = &matrix)
             GetFloat(pname, (float*)ptr);
     }
 }

		internal static extern void glGetIntegerv(GetPName pname, [OutAttribute] Int32* @params);

        public void Analyze(GetPName pname, eType type)
        {
            bool result1b;
            int result1i;
            int[] result2i = new int[2];
            int[] result4i = new int[4];
            float result1f;
            Vector2 result2f;
            Vector4 result4f;
            string output;

            switch (type)
            {
                case eType.Boolean:
                    GL.GetBoolean(pname, out result1b);
                    output = pname + ": " + result1b;
                    break;
                case eType.Int:
                    GL.GetInteger(pname, out result1i);
                    output = pname + ": " + result1i;
                    break;
                case eType.IntEnum:
                    GL.GetInteger(pname, out result1i);
                    output = pname + ": " + (All)result1i;
                    break;
                case eType.IntArray2:
                    GL.GetInteger(pname, result2i);
                    output = pname + ": ( " + result2i[0] + ", " + result2i[1] + " )";
                    break;
                case eType.IntArray4:
                    GL.GetInteger(pname, result4i);
                    output = pname + ": ( " + result4i[0] + ", " + result4i[1] + " ) ( " + result4i[2] + ", " + result4i[3] + " )";
                    break;
                case eType.Float:
                    GL.GetFloat(pname, out result1f);
                    output = pname + ": " + result1f;
                    break;
                case eType.FloatArray2:
                    GL.GetFloat(pname, out result2f);
                    output = pname + ": ( " + result2f.X + ", " + result2f.Y + " )";
                    break;
                case eType.FloatArray4:
                    GL.GetFloat(pname, out result4f);
                    output = pname + ": ( " + result4f.X + ", " + result4f.Y + ", " + result4f.Z + ", " + result4f.W + " )";
                    break;
                default: throw new NotImplementedException();
            }

            ErrorCode err = GL.GetError();
            if (err != ErrorCode.NoError)
                Trace.WriteLine("Unsupported Token: " + pname);
            else
                Trace.WriteLine(output);

        }

 internal static Vector2d GetVector2d(GetPName pname)
 {
     lock (doubleArray) {
         using (Lock())
             GL.GetDouble(pname, doubleArray);
         return new Vector2d(doubleArray);
     }
 }

		internal static extern void glGetDoublev(GetPName pname, [OutAttribute] Double* @params);

        internal static int GetInt32(GetPName pname)
        {
            int result;

            try {
                using (Lock())
                    GL.GetInteger(pname, out result);
            } catch (Exception exception) {
                throw new InvalidOperationException("Exception thrown with GetInt32(GetPName." + pname + ")", exception);
            }

            return result;
        }

 internal static double GetDouble(GetPName pname)
 {
     double result; using (Lock()) GL.GetDouble(pname, out result); return result;
 }

 public static int GetGLInfoInt(GetPName name)
 {
     int res;
     GL.GetInteger(name, out res);
     return res;
 }

 public static float GetGLInfoFloat(GetPName name)
 {
     float res;
     GL.GetFloat(name, out res);
     return res;
 }

 public static extern void GetIntegerv( GetPName pname, [Out]int[] @params );

		public static void Get(GetPName pname, out float data)
		{
			unsafe {
				fixed (float* p_data = &data)
				{
					Debug.Assert(Delegates.pglGetFloatv != null, "pglGetFloatv not implemented");
					Delegates.pglGetFloatv((Int32)pname, p_data);
					LogFunction("glGetFloatv({0}, {1})", pname, data);
				}
			}
			DebugCheckErrors(null);
		}

		internal static extern void glGetBooleanv(GetPName pname, [OutAttribute] bool* @params);

		internal static extern void glGetFloatv(GetPName pname, [OutAttribute] Single* @params);

 internal PipelineShaderStageCapabilities(ShaderStage stage, GetPName maxAtomicCounterBuffers, GetPName maxAtomicCounters, GetPName maxCombinedUniformComponents, GetPName maxImageUniforms, GetPName maxShaderStorageBlocks, GetPName maxTextureImageUnits, GetPName maxUniformBlocks, GetPName maxUniformComponents)
     : base(stage, maxAtomicCounterBuffers, maxAtomicCounters, maxImageUniforms, maxShaderStorageBlocks, maxTextureImageUnits, maxUniformBlocks)
 {
     this.maxCombinedUniformComponents = maxCombinedUniformComponents;
     this.maxUniformComponents = maxUniformComponents;
 }

		public static int GlGetInteger(GetPName Name)
		{
			int Value;
			GL.GetInteger(Name, out Value);
			return Value;
		}

        internal ShaderStageCapabilities(ShaderStage stage, GetPName maxAtomicCounterBuffers, GetPName maxAtomicCounters, GetPName maxImageUniforms, GetPName maxShaderStorageBlocks, GetPName maxTextureImageUnits, GetPName maxUniformBlocks)
        {
            this.stage = stage;

            this.maxAtomicCounterBuffers = maxAtomicCounterBuffers;
            this.maxAtomicCounters = maxAtomicCounters;
            this.maxImageUniforms = maxImageUniforms;
            this.maxShaderStorageBlocks = maxShaderStorageBlocks;
            this.maxTextureImageUnits = maxTextureImageUnits;
            this.maxUniformBlocks = maxUniformBlocks;
        }

 public static extern void GetBooleanv( GetPName pname, [Out]bool[] @params );

 public static extern void GetDoublev( GetPName pname, [Out]double[] @params );