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 void NormalPointer(int size, NormalPointerType type, int stride, int pointer)
{
NormalPointer(type, stride, (IntPtr)pointer);
}
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());
}
internal static extern void glNormalPointer(NormalPointerType type, Int32 stride, IntPtr pointer);
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, int offset)
{
NormalPointer(type, stride, (IntPtr)offset);
}
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);
}
