public static void NormalPointerEXT(NormalPointerType type, Int32 stride, Int32 count, IntPtr pointer) { Debug.Assert(Delegates.pglNormalPointerEXT != null, "pglNormalPointerEXT not implemented"); Delegates.pglNormalPointerEXT((Int32)type, stride, count, pointer); LogFunction("glNormalPointerEXT({0}, {1}, {2}, 0x{3})", type, stride, count, pointer.ToString("X8")); DebugCheckErrors(null); }
public static void NormalPointerEXT(NormalPointerType type, int stride, int count, IntPtr pointer) { Debug.Assert(Delegates.pglNormalPointerEXT != null, "pglNormalPointerEXT not implemented"); Delegates.pglNormalPointerEXT((int)type, stride, count, pointer); LogCommand("glNormalPointerEXT", null, type, stride, count, pointer); DebugCheckErrors(null); }
public static void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { #if USE_OPENGL OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, pointer); #else OpenTK.Graphics.ES11.GL.NormalPointer((OpenTK.Graphics.ES11.All)type, stride, pointer); #endif }
public void NormalPointer(NormalPointerType type, int stride, float[] pointer) { unsafe { fixed(float *pArray = pointer) { NormalPointer(type, stride, new IntPtr(pArray)); } } }
public static void NormalPointerEXT(NormalPointerType type, int stride, int count, object pointer) { GCHandle pin_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned); try { NormalPointerEXT(type, stride, count, pin_pointer.AddrOfPinnedObject()); } finally { pin_pointer.Free(); } }
public static void NormalPointer(NormalPointerType type, int stride, float[] pointer) { unsafe { fixed(float *floatPointer = pointer) { NormalPointer(type, stride, (IntPtr)floatPointer); } } }
public static void NormalPointerINTEL(NormalPointerType type, IntPtr[] pointer) { unsafe { fixed(IntPtr *p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointervINTEL != null, "pglNormalPointervINTEL not implemented"); Delegates.pglNormalPointervINTEL((Int32)type, p_pointer); LogFunction("glNormalPointervINTEL({0}, {1})", type, LogValue(pointer)); } } DebugCheckErrors(null); }
public static void NormalPointerListIBM(NormalPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride) { unsafe { fixed(IntPtr *p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointerListIBM != null, "pglNormalPointerListIBM not implemented"); Delegates.pglNormalPointerListIBM((Int32)type, stride, p_pointer, ptrstride); LogFunction("glNormalPointerListIBM({0}, {1}, {2}, {3})", type, stride, LogValue(pointer), ptrstride); } } DebugCheckErrors(null); }
public static void NormalPointerINTEL(NormalPointerType type, IntPtr[] pointer) { unsafe { fixed(IntPtr *p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointervINTEL != null, "pglNormalPointervINTEL not implemented"); Delegates.pglNormalPointervINTEL((Int32)type, p_pointer); LogCommand("glNormalPointervINTEL", null, type, pointer); } } DebugCheckErrors(null); }
public static void NormalPointerListIBM(NormalPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride) { unsafe { fixed(IntPtr *p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointerListIBM != null, "pglNormalPointerListIBM not implemented"); Delegates.pglNormalPointerListIBM((Int32)type, stride, p_pointer, ptrstride); LogCommand("glNormalPointerListIBM", null, type, stride, pointer, ptrstride); } } DebugCheckErrors(null); }
public static void NormalPointer(NormalPointerType type, int stride, float[] pointer) { #if USE_OPENGL OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, pointer); #else unsafe { fixed(float *pArray = pointer) { NormalPointer(type, stride, new IntPtr(pArray)); } } #endif }
public static void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { #if USE_OPENGL if (HardwareAvailable) { if (glHasBufferObjects || currentArrayBufferIndex == 0) { OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, pointer); } else { unsafe { fixed(byte *buffer = bufferData[currentArrayBufferIndex]) { OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, new IntPtr(&buffer[(int)pointer])); } } } } #else if (glHasBufferObjects || currentArrayBufferIndex == 0) { OpenTK.Graphics.ES11.GL.NormalPointer((OpenTK.Graphics.ES11.All)type, stride, pointer); } else { unsafe { fixed(byte *buffer = bufferData[currentArrayBufferIndex]) { OpenTK.Graphics.ES11.GL.NormalPointer((OpenTK.Graphics.ES11.All)type, stride, new IntPtr(&buffer[(int)pointer])); } } } #endif }
public static int GetSizeInBytes(NormalPointerType pointerType) { switch (pointerType) { case NormalPointerType.Byte: return(SByte); case NormalPointerType.Short: return(Short); case NormalPointerType.Int: return(Int); case NormalPointerType.HalfFloat: return(Float); case NormalPointerType.Float: return(Float); case NormalPointerType.Double: return(Double); } throw new NotSupportedException(pointerType + " is not supported for Normal pointer"); }
public static unsafe extern void NormalPointervINTEL( NormalPointerType type, void** pointer );
public abstract unsafe void NormalPointer([Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] uint stride, [Flow(FlowDirection.In)] uint count, [Count(Computed = "type, stride, count"), Flow(FlowDirection.In)] void *pointer);
public static void NormalPointer(NormalPointerType type, int stride, float[] pointer) { #if USE_OPENGL if (openGlHardwareAvailable) { OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, pointer); } #else unsafe { fixed (float* pArray = pointer) { NormalPointer(type, stride, new IntPtr(pArray)); } } #endif }
public abstract void NormalP3([Flow(FlowDirection.In)] NormalPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] ref uint coords);
public abstract void NormalPointer <T0>([Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] uint stride, [Flow(FlowDirection.In)] uint count, [Count(Computed = "type, stride, count"), Flow(FlowDirection.In)] ref T0 pointer) where T0 : unmanaged;
public static void VertexArrayNormalOffsetEXT(UInt32 vaobj, UInt32 buffer, NormalPointerType type, Int32 stride, IntPtr offset) { Debug.Assert(Delegates.pglVertexArrayNormalOffsetEXT != null, "pglVertexArrayNormalOffsetEXT not implemented"); Delegates.pglVertexArrayNormalOffsetEXT(vaobj, buffer, (Int32)type, stride, offset); CallLog("glVertexArrayNormalOffsetEXT({0}, {1}, {2}, {3}, 0x{4})", vaobj, buffer, type, stride, offset.ToString("X8")); DebugCheckErrors(); }
public abstract void NormalP3([Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] uint coords);
public abstract unsafe void NormalPointerList <T0>([Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] int stride, [Count(Computed = "type, stride"), Flow(FlowDirection.In)] ref T0 *pointer, [Flow(FlowDirection.In)] int ptrstride) where T0 : unmanaged;
//public void NormalPointer(NormalPointerType type, int stride, byte[] pointer) //{ // gl.glNormalPointer((int)type, stride, pointer); // CheckException(); //} //public void NormalPointer(NormalPointerType type, int stride, short[] pointer) //{ // gl.glNormalPointer((int)type, stride, pointer); // CheckException(); //} //public void NormalPointer(NormalPointerType type, int stride, int[] pointer) //{ // gl.glNormalPointer((int)type, stride, pointer); // CheckException(); //} public void NormalPointer(NormalPointerType type, int stride, float[] pointer) { gl.glNormalPointer((int)type, stride, pointer); CheckException(); }
public static void NormalPointer(NormalPointerType type, Int32 stride, Object pointer) { GCHandle pin_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned); try { NormalPointer(type, stride, pin_pointer.AddrOfPinnedObject()); } finally { pin_pointer.Free(); } }
public abstract unsafe void NormalPointerList([Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] int stride, [Count(Computed = "type, stride"), Flow(FlowDirection.In)] void **pointer, [Flow(FlowDirection.In)] int ptrstride);
public static void NormalPointer(NormalPointerType type, Int32 stride, IntPtr pointer) { Debug.Assert(Delegates.pglNormalPointer != null, "pglNormalPointer not implemented"); Delegates.pglNormalPointer((Int32)type, stride, pointer); LogFunction("glNormalPointer({0}, {1}, 0x{2})", type, stride, pointer.ToString("X8")); DebugCheckErrors(null); }
public static void NormalPointer(NormalPointerType type, int stride, double[] pointer) { gl.glNormalPointer((int)type, stride, pointer); }
public static unsafe extern void NormalPointerListIBM( NormalPointerType type, int stride, void** pointer, int ptrstride );
public static void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { Instance?.NormalPointer(type, stride, pointer); }
public void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { glNormalPointer((int)type, stride, pointer); }
public static void glNormalPointer(NormalPointerType type, Int32 stride, IntPtr pointer) { i_OpenGL1_1.glNormalPointer(type, stride, pointer); }
public static unsafe extern void NormalPointer( NormalPointerType type, int stride, void* pointer );
public static void NormalPointer(NormalPointerType type, int stride, int offset) { NormalPointer(type, stride, (IntPtr)offset); }
public static void NormalPointer(int size, NormalPointerType type, int stride, int pointer) { NormalPointer(type, stride, (IntPtr)pointer); }
public abstract unsafe void NormalP3([Flow(FlowDirection.In)] NormalPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] uint *coords);
internal static extern void glNormalPointer(NormalPointerType type, Int32 stride, IntPtr pointer);
public static void NormalPointerListIBM(NormalPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride) { unsafe { fixed (IntPtr* p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointerListIBM != null, "pglNormalPointerListIBM not implemented"); Delegates.pglNormalPointerListIBM((Int32)type, stride, p_pointer, ptrstride); CallLog("glNormalPointerListIBM({0}, {1}, {2}, {3})", type, stride, pointer, ptrstride); } } DebugCheckErrors(); }
public static void NormalPointerEXT(NormalPointerType type, Int32 stride, Int32 count, IntPtr pointer) { Debug.Assert(Delegates.pglNormalPointerEXT != null, "pglNormalPointerEXT not implemented"); Delegates.pglNormalPointerEXT((Int32)type, stride, count, pointer); CallLog("glNormalPointerEXT({0}, {1}, {2}, 0x{3})", type, stride, count, pointer.ToString("X8")); DebugCheckErrors(); }
public static unsafe void NormalPointerEXT( NormalPointerType type, int stride, int count, void* pointer ) { if (_NormalPointerEXT == null) throw new Exception( "Extension method NormalPointerEXT not found" ); _NormalPointerEXT( type, stride, count, pointer ); }
public static unsafe void NormalPointer <T0>(this ExtVertexArray thisApi, [Flow(FlowDirection.In)] NormalPointerType type, [Flow(FlowDirection.In)] uint stride, [Flow(FlowDirection.In)] uint count, [Count(Computed = "type, stride, count"), Flow(FlowDirection.In)] ReadOnlySpan <T0> pointer) where T0 : unmanaged { // SpanOverloader thisApi.NormalPointer(type, stride, count, in pointer.GetPinnableReference()); }
public static void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { #if USE_OPENGL if (openGlHardwareAvailable) { if (glHasBufferObjects || currentArrayBufferIndex == 0) { OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, pointer); } else { unsafe { fixed (byte* buffer = bufferData[currentArrayBufferIndex]) { OpenTK.Graphics.OpenGL.GL.NormalPointer((OpenTK.Graphics.OpenGL.NormalPointerType)type, stride, new IntPtr(&buffer[(int)pointer])); } } } } #else if (glHasBufferObjects || currentArrayBufferIndex == 0) { OpenTK.Graphics.ES11.GL.NormalPointer((OpenTK.Graphics.ES11.All)type, stride, pointer); } else { unsafe { fixed (byte* buffer = bufferData[currentArrayBufferIndex]) { OpenTK.Graphics.ES11.GL.NormalPointer((OpenTK.Graphics.ES11.All)type, stride, new IntPtr(&buffer[(int)pointer])); } } } #endif }
public static void NormalPointer(NormalPointerType type, int stride, IntPtr pointer) { Interop.Calli((int)type, stride, pointer, NormalPointerAddress); }
public abstract unsafe void NormalPointer([Flow(FlowDirection.In)] NormalPointerType type, [Count(Count = 4), Flow(FlowDirection.In)] void **pointer);
public static unsafe void NormalP3(this ArbVertexType2101010Rev thisApi, [Flow(FlowDirection.In)] NormalPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] ReadOnlySpan <uint> coords) { // SpanOverloader thisApi.NormalP3(type, in coords.GetPinnableReference()); }
public static void NormalPointerINTEL(NormalPointerType type, IntPtr[] pointer) { unsafe { fixed (IntPtr* p_pointer = pointer) { Debug.Assert(Delegates.pglNormalPointervINTEL != null, "pglNormalPointervINTEL not implemented"); Delegates.pglNormalPointervINTEL((Int32)type, p_pointer); LogFunction("glNormalPointervINTEL({0}, {1})", type, LogValue(pointer)); } } DebugCheckErrors(null); }