public static void GetFloat(GetPName pname, out Matrix4 matrix) { unsafe { fixed (Matrix4* ptr = &matrix) GetFloat(pname, (float*)ptr); } }
public static double GetGLInfoDouble(GetPName name) { double res; GL.GetDouble(name, out res); return res; }
public abstract void GetUnsignedByte([Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] string data);
public static void GetDouble(GetPName pname, out Vector4d vector) { unsafe { fixed (Vector4d* ptr = &vector) GetDouble(pname, (double*)ptr); } }
public abstract unsafe void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] long *data);
public static void glGetFloatv(GetPName pname, ref Single[] data) { i_OpenGL1_0.glGetFloatv(pname, ref data); }
internal static Vector2d GetVector2d(GetPName pname) { lock (doubleArray) { using (Lock()) GL.GetDouble(pname, doubleArray); return new Vector2d(doubleArray); } }
internal static extern void glGetIntegerv(GetPName pname, [OutAttribute] Int32 * @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 int GetInt32(GetPName pname, int defaultValue) { int result; GL.GetInteger(pname, out result); var error = GL.GetError(); switch (error) { case ErrorCode.NoError: return result; case ErrorCode.InvalidEnum: return defaultValue; default: throw new InvalidOperationException("Exception thrown with GetInt32(GetPName." + pname + "): ", CreateError(error)); } }
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 unsafe void GetInteger(this ExtMultiviewDrawBuffers thisApi, [Flow(FlowDirection.In)] GetPName target, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.Out)] Span <int> data) { // SpanOverloader thisApi.GetInteger(target, index, out data.GetPinnableReference()); }
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 glGetDoublev(GetPName pname, [OutAttribute] Double * @params);
public static void Get(GetPName pname, [Out] Int32[] data) { unsafe { fixed (Int32* p_data = data) { Debug.Assert(Delegates.pglGetIntegerv != null, "pglGetIntegerv not implemented"); Delegates.pglGetIntegerv((Int32)pname, p_data); LogFunction("glGetIntegerv({0}, {1})", pname, LogValue(data)); } } DebugCheckErrors(null); }
public unsafe partial void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] long * @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 void glGetBooleanv(GetPName pname, ref Boolean[] data) { i_OpenGL1_0.glGetBooleanv(pname, ref data); }
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 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); }
/// <summary> /// OpenGLのプロパティを取得します。 /// </summary> private static string Analyze(GetPName pname, GLType type) { string output; switch (type) { case GLType.Boolean: bool result1b; GL.GetBoolean(pname, out result1b); output = pname + ": " + result1b; break; case GLType.Int: int result1i; GL.GetInteger(pname, out result1i); output = pname + ": " + result1i; break; case GLType.IntEnum: int result1e; GL.GetInteger(pname, out result1e); output = pname + ": " + (All)result1e; break; case GLType.IntArray2: int[] result2i = new int[2]; GL.GetInteger(pname, result2i); output = pname + ": ( " + result2i[0] + ", " + result2i[1] + " )"; break; case GLType.IntArray4: int[] result4i = new int[4]; GL.GetInteger(pname, result4i); output = pname + ": ( " + result4i[0] + ", " + result4i[1] + " ) ( " + result4i[2] + ", " + result4i[3] + " )"; break; case GLType.Float: float result1f; GL.GetFloat(pname, out result1f); output = pname + ": " + result1f; break; case GLType.FloatArray2: Vector2 result2f; GL.GetFloat(pname, out result2f); output = pname + ": ( " + result2f.X + ", " + result2f.Y + " )"; break; case GLType.FloatArray4: Vector4 result4f; GL.GetFloat(pname, out result4f); output = pname + ": ( " + result4f.X + ", " + result4f.Y + ", " + result4f.Z + ", " + result4f.W + " )"; break; default: throw new NotImplementedException(); } var err = GL.GetError(); if (err != ErrorCode.NoError) { //Log.Error("Unsupported Token: " + pname); } return(output); }
/// <summary> /// Returns the double value of a selected parameter. /// </summary> /// <param name="pname">A parameter that returns a single double.</param> public static double GetDouble(GetPName pname) { GetDoublev(pname, double1); return(double1[0]); }
public partial void GetIntegerIndexed([Flow(FlowDirection.In)] GetPName target, [Flow(FlowDirection.In)] uint index, [Count(Computed = "target"), Flow(FlowDirection.Out)] out int data);
/// <summary> /// Returns the value or values of a selected parameter. /// </summary> /// <param name="pname">Supports Blend, CullFace, DepthTest, DepthWriteMask, </param> /// <returns></returns> public static bool GetBooleanv(GetPName pname) { GetBooleanv(pname, bool1); return(bool1[0]); }
public static unsafe void GetFloat(this OesViewportArray thisApi, [Flow(FlowDirection.In)] GetPName target, [Flow(FlowDirection.In)] uint index, [Count(Computed = "target"), Flow(FlowDirection.Out)] Span <float> data) { // SpanOverloader thisApi.GetFloat(target, index, out data.GetPinnableReference()); }
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 extern void GetBooleanv( GetPName pname, [Out]bool[] @params );
public static void GetIntegerv(GetPName pname, int * @params) { Interop.Calli((int)pname, @params, GetIntegervAddress); }
public static extern void GetDoublev( GetPName pname, [Out]double[] @params );
internal static extern void glGetBooleanv(GetPName pname, [OutAttribute] bool * @params);
public static extern void GetFloatv( GetPName pname, [Out]float[] @params );
internal static extern void glGetFloatv(GetPName pname, [OutAttribute] Single * @params);
public static extern void GetIntegerv( GetPName pname, [Out]int[] @params );
public static int GlGetInteger(GetPName Name) { int Value; GL.GetInteger(Name, out Value); return Value; }
public static unsafe void GetFixed(this OesFixedPoint thisApi, [Flow(FlowDirection.In)] GetPName pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] Span <int> @params) { // SpanOverloader thisApi.GetFixed(pname, out @params.GetPinnableReference()); }
public partial void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] out long @params);
public static unsafe void GetInteger64(this AppleSync thisApi, [Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] Span <long> @params) { // SpanOverloader thisApi.GetInteger64(pname, out @params.GetPinnableReference()); }
public static unsafe void GetIntegerIndexed(this ExtDrawBuffers2 thisApi, [Flow(FlowDirection.In)] GetPName target, [Flow(FlowDirection.In)] uint index, [Count(Computed = "target"), Flow(FlowDirection.Out)] Span <int> data) { // SpanOverloader thisApi.GetIntegerIndexed(target, index, out data.GetPinnableReference()); }
public abstract unsafe void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] long * @params);
public static void glGetDoublev(GetPName pname, ref Double[] data) { i_OpenGL1_0.glGetDoublev(pname, ref data); }
public abstract void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Flow(FlowDirection.Out)] Span <long> @params);
public static void glGetIntegerv(GetPName pname, ref Int32[] data) { i_OpenGL1_0.glGetIntegerv(pname, ref data); }
public static unsafe void GetUnsignedByte(this ExtMemoryObject thisApi, [Flow(FlowDirection.In)] GetPName pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] Span <byte> data) { // SpanOverloader thisApi.GetUnsignedByte(pname, out data.GetPinnableReference()); }
public partial void GetInteger64([Flow(FlowDirection.In)] GetPName pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] out long data);
/// <summary> /// Return the value of the selected parameter. /// </summary> /// <param name="name">Specifies the parameter value to be returned.</param> public static int GetInteger(GetPName name) { GetIntegerv(name, getInteger); return(getInteger[0]); }
/// <summary> /// Returns the float value of a selected parameter. /// </summary> /// <param name="pname">A parameter that returns a single float.</param> public static float GetFloat(GetPName pname) { GetFloatv(pname, float1); return(float1[0]); }
internal static extern void glGetBooleanv(GetPName pname, [OutAttribute] bool* @params);
/// <summary> /// Returns the integer value of a selected parameter. /// </summary> /// <param name="name">A parameter that returns a single integer.</param> public static int GetInteger(GetPName name) { GetIntegerv(name, int1); return(int1[0]); }
internal static extern void glGetDoublev(GetPName pname, [OutAttribute] Double* @params);
public static void GetDouble(GetPName pname, out Matrix4d matrix) { unsafe { fixed (Matrix4d* ptr = &matrix) GetDouble(pname, (double*)ptr); } }
internal static extern void glGetFloatv(GetPName pname, [OutAttribute] Single* @params);
public static void GetFloat(GetPName pname, out Vector4 vector) { unsafe { fixed (Vector4* ptr = &vector) GetFloat(pname, (float*)ptr); } }
internal static extern void glGetIntegerv(GetPName pname, [OutAttribute] Int32* @params);
public static int GetInteger(GetPName name) { int outval; GL.GetInteger(name, out outval); return outval; }
public static void GetFloatv(GetPName pname, float * @params) { Interop.Calli((int)pname, @params, GetFloatvAddress); }
public static void Get(GetPName pname, out Int32 data) { unsafe { fixed (Int32* p_data = &data) { Debug.Assert(Delegates.pglGetIntegerv != null, "pglGetIntegerv not implemented"); Delegates.pglGetIntegerv((Int32)pname, p_data); CallLog("glGetIntegerv({0}, {1})", pname, data); } } DebugCheckErrors(); }
public static bool GetGLInfoBool(GetPName name) { bool res; GL.GetBoolean(name, out res); return res; }