public VertexAttribute(int coordinateCount, VertexPointerType pointerType, int stride, int offset)
{
this.CoordinateCount = coordinateCount;
this.PointerType = pointerType;
this.Stride = stride;
this.Offset = offset;
}
public static void VertexPointerEXT(Int32 size, VertexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
{
Debug.Assert(Delegates.pglVertexPointerEXT != null, "pglVertexPointerEXT not implemented");
Delegates.pglVertexPointerEXT(size, (Int32)type, stride, count, pointer);
LogFunction("glVertexPointerEXT({0}, {1}, {2}, {3}, 0x{4})", size, type, stride, count, pointer.ToString("X8"));
DebugCheckErrors(null);
}
public static void VertexFormatNV(int size, VertexPointerType type, int stride)
{
Debug.Assert(Delegates.pglVertexFormatNV != null, "pglVertexFormatNV not implemented");
Delegates.pglVertexFormatNV(size, (int)type, stride);
LogCommand("glVertexFormatNV", null, size, type, stride);
DebugCheckErrors(null);
}
public static void VertexPointerEXT(int size, VertexPointerType type, int stride, int count, IntPtr pointer)
{
Debug.Assert(Delegates.pglVertexPointerEXT != null, "pglVertexPointerEXT not implemented");
Delegates.pglVertexPointerEXT(size, (int)type, stride, count, pointer);
LogCommand("glVertexPointerEXT", null, size, type, stride, count, pointer);
DebugCheckErrors(null);
}
public VertexAttribute(int coordinateCount, VertexPointerType pointerType, int stride, int offset)
{
this.CoordinateCount = coordinateCount;
this.PointerType = pointerType;
this.Stride = stride;
this.Offset = offset;
}
public static void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
#if USE_OPENGL
OpenTK.Graphics.OpenGL.GL.VertexPointer(size, (OpenTK.Graphics.OpenGL.VertexPointerType)type, stride, pointer);
#else
OpenTK.Graphics.ES11.GL.VertexPointer(size, (OpenTK.Graphics.ES11.All)type, stride, pointer);
#endif
}
public VertexFormatElement(VertexFormatSemantic semantic, VertexPointerType type, byte count, short offset, short divisor = 0)
{
Semantic = semantic;
Type = type;
Count = count;
Offset = offset;
Divisor = divisor;
}
public VertexPointerInfo(int coordinateCount,
VertexPointerType pointerType,
int stride,
int offset)
{
this.coordinateCount = coordinateCount;
this.pointerType = pointerType;
this.stride = stride;
this.offset = offset;
}
public VertexPointerInfo(int coordinateCount,
VertexPointerType pointerType,
int stride,
int offset)
{
this.coordinateCount = coordinateCount;
this.pointerType = pointerType;
this.stride = stride;
this.offset = offset;
}
public static void VertexPointerEXT(int size, VertexPointerType type, int stride, int count, object pointer)
{
GCHandle pin_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
try {
VertexPointerEXT(size, type, stride, count, pin_pointer.AddrOfPinnedObject());
} finally {
pin_pointer.Free();
}
}
public static void VertexPointer(int size, VertexPointerType type, int stride, float[] pointer)
{
unsafe
{
fixed(float *pArray = pointer)
{
VertexPointer(size, type, stride, new IntPtr(pArray));
}
}
}
public static void VertexPointerINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
{
unsafe {
fixed (IntPtr* p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointervINTEL != null, "pglVertexPointervINTEL not implemented");
Delegates.pglVertexPointervINTEL(size, (Int32)type, p_pointer);
LogFunction("glVertexPointervINTEL({0}, {1}, {2})", size, type, LogValue(pointer));
}
}
DebugCheckErrors(null);
}
public static void VertexPointerINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
{
unsafe
{
fixed(IntPtr *p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointervINTEL != null, "pglVertexPointervINTEL not implemented");
Delegates.pglVertexPointervINTEL(size, (Int32)type, p_pointer);
LogFunction("glVertexPointervINTEL({0}, {1}, {2})", size, type, LogValue(pointer));
}
}
DebugCheckErrors(null);
}
public static void VertexPointerListIBM(Int32 size, VertexPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
{
unsafe
{
fixed(IntPtr *p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointerListIBM != null, "pglVertexPointerListIBM not implemented");
Delegates.pglVertexPointerListIBM(size, (Int32)type, stride, p_pointer, ptrstride);
LogFunction("glVertexPointerListIBM({0}, {1}, {2}, {3}, {4})", size, type, stride, LogValue(pointer), ptrstride);
}
}
DebugCheckErrors(null);
}
public static void VertexPointerINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
{
unsafe
{
fixed(IntPtr *p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointervINTEL != null, "pglVertexPointervINTEL not implemented");
Delegates.pglVertexPointervINTEL(size, (Int32)type, p_pointer);
LogCommand("glVertexPointervINTEL", null, size, type, pointer);
}
}
DebugCheckErrors(null);
}
public static void VertexPointerListIBM(Int32 size, VertexPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
{
unsafe
{
fixed(IntPtr *p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointerListIBM != null, "pglVertexPointerListIBM not implemented");
Delegates.pglVertexPointerListIBM(size, (Int32)type, stride, p_pointer, ptrstride);
LogCommand("glVertexPointerListIBM", null, size, type, stride, pointer, ptrstride);
}
}
DebugCheckErrors(null);
}
public static int GetSizeInBytes(VertexPointerType pointerType)
{
switch (pointerType)
{
case VertexPointerType.Short:
return(Short);
case VertexPointerType.Int:
return(Int);
case VertexPointerType.HalfFloat:
return(Float);
case VertexPointerType.Float:
return(Float);
case VertexPointerType.Double:
return(Double);
}
throw new NotSupportedException(pointerType + " is not supported for Vertex pointer");
}
public static void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
#if USE_OPENGL
if (HardwareAvailable)
{
if (glHasBufferObjects || currentArrayBufferIndex == 0)
{
OpenTK.Graphics.OpenGL.GL.VertexPointer(size, (OpenTK.Graphics.OpenGL.VertexPointerType)type, stride, pointer);
}
else
{
unsafe
{
fixed(byte *buffer = bufferData[currentArrayBufferIndex])
{
OpenTK.Graphics.OpenGL.GL.VertexPointer(size, (OpenTK.Graphics.OpenGL.VertexPointerType)type, stride, new IntPtr(&buffer[(int)pointer]));
}
}
}
}
#else
if (glHasBufferObjects || currentArrayBufferIndex == 0)
{
OpenTK.Graphics.ES11.GL.VertexPointer(size, (OpenTK.Graphics.ES11.All)type, stride, pointer);
}
else
{
unsafe
{
fixed(byte *buffer = bufferData[currentArrayBufferIndex])
{
OpenTK.Graphics.ES11.GL.VertexPointer(size, (OpenTK.Graphics.ES11.All)type, stride, new IntPtr(&buffer[(int)pointer]));
}
}
}
#endif
}
public static unsafe void VertexPointerEXT( int size, VertexPointerType type, int stride, int count, void* pointer )
{
if (_VertexPointerEXT == null) throw new Exception( "Extension method VertexPointerEXT not found" );
_VertexPointerEXT( size, type, stride, count, pointer );
}
public static void VertexPointer(int size, VertexPointerType type, int stride, float[] pointer)
{
unsafe
{
fixed (float* pArray = pointer)
{
VertexPointer(size, type, stride, new IntPtr(pArray));
}
}
}
public static void VertexPointerEXT(Int32 size, VertexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
{
Debug.Assert(Delegates.pglVertexPointerEXT != null, "pglVertexPointerEXT not implemented");
Delegates.pglVertexPointerEXT(size, (Int32)type, stride, count, pointer);
CallLog("glVertexPointerEXT({0}, {1}, {2}, {3}, 0x{4})", size, type, stride, count, pointer.ToString("X8"));
DebugCheckErrors();
}
public abstract void VertexP4([Flow(FlowDirection.In)] VertexPointerType type, [Flow(FlowDirection.In)] uint value);
public abstract void VertexP4([Flow(FlowDirection.In)] VertexPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] ref uint value);
public void VertexPointer(int size, VertexPointerType type, int stride, object pointer)
{
gl.glVertexPointer(size, (int)type, stride, pointer);
CheckException();
}
public static void VertexPointer(Int32 size, VertexPointerType type, Int32 stride, IntPtr pointer)
{
Debug.Assert(Delegates.pglVertexPointer != null, "pglVertexPointer not implemented");
Delegates.pglVertexPointer(size, (Int32)type, stride, pointer);
LogFunction("glVertexPointer({0}, {1}, {2}, 0x{3})", size, type, stride, pointer.ToString("X8"));
DebugCheckErrors(null);
}
public abstract unsafe void VertexPointerList([Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexPointerType type, [Flow(FlowDirection.In)] int stride, [Count(Computed = "size, type, stride"), Flow(FlowDirection.In)] void **pointer, [Flow(FlowDirection.In)] int ptrstride);
public abstract unsafe void VertexPointerList <T0>([Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexPointerType type, [Flow(FlowDirection.In)] int stride, [Count(Computed = "size, type, stride"), Flow(FlowDirection.In)] ref T0 *pointer, [Flow(FlowDirection.In)] int ptrstride) where T0 : unmanaged;
public VertexAttribute(int coordinateCount, VertexPointerType pointerType)
: this(coordinateCount, pointerType, 0, 0)
{
}
public VertexAttribute(int coordinateCount, VertexPointerType pointerType)
: this(coordinateCount, pointerType, 0, 0)
{
}
public static void VertexPointer(Int32 size, VertexPointerType type, Int32 stride, Object pointer)
{
GCHandle pin_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
try {
VertexPointer(size, type, stride, pin_pointer.AddrOfPinnedObject());
} finally {
pin_pointer.Free();
}
}
public static void TexCoordPointerINTEL(Int32 size, VertexPointerType type, IntPtr[] pointer)
{
unsafe {
fixed (IntPtr* p_pointer = pointer)
{
Debug.Assert(Delegates.pglTexCoordPointervINTEL != null, "pglTexCoordPointervINTEL not implemented");
Delegates.pglTexCoordPointervINTEL(size, (Int32)type, p_pointer);
CallLog("glTexCoordPointervINTEL({0}, {1}, {2})", size, type, pointer);
}
}
DebugCheckErrors();
}
public static unsafe extern void VertexPointerListIBM( int size, VertexPointerType type, int stride, void** pointer, int ptrstride );
public static void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
Instance?.VertexPointer(size, type, stride, pointer);
}
public static void glVertexPointer(Int32 size, VertexPointerType type, Int32 stride, IntPtr pointer)
{
i_OpenGL1_1.glVertexPointer(size, type, stride, pointer);
}
public static void VertexPointer(int size, VertexPointerType type, int stride, int offset)
{
VertexPointer(size, type, stride, (IntPtr)offset);
}
public static void VertexPointer(int size, VertexPointerType type, int stride, int pointer)
{
VertexPointer(size, type, stride, (IntPtr)pointer);
}
public abstract unsafe void VertexP4([Flow(FlowDirection.In)] VertexPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] uint *value);
internal static extern void glVertexPointer(Int32 size, VertexPointerType type, Int32 stride, IntPtr pointer);
public static void VertexPointerListIBM(Int32 size, VertexPointerType type, Int32 stride, IntPtr[] pointer, Int32 ptrstride)
{
unsafe {
fixed (IntPtr* p_pointer = pointer)
{
Debug.Assert(Delegates.pglVertexPointerListIBM != null, "pglVertexPointerListIBM not implemented");
Delegates.pglVertexPointerListIBM(size, (Int32)type, stride, p_pointer, ptrstride);
CallLog("glVertexPointerListIBM({0}, {1}, {2}, {3}, {4})", size, type, stride, pointer, ptrstride);
}
}
DebugCheckErrors();
}
public void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
glVertexPointer(size, (int)type, stride, pointer);
}
public static void VertexPointer(int size, VertexPointerType type, int stride, int pointer)
{
VertexPointer(size, type, stride, (IntPtr)pointer);
}
public static unsafe extern void VertexPointer( int size, VertexPointerType type, int stride, void* pointer );
public static unsafe void VertexPointer <T0>(this ExtVertexArray thisApi, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexPointerType type, [Flow(FlowDirection.In)] uint stride, [Flow(FlowDirection.In)] uint count, [Count(Computed = "size, type, stride, count"), Flow(FlowDirection.In)] ReadOnlySpan <T0> pointer) where T0 : unmanaged
{
// SpanOverloader
thisApi.VertexPointer(size, type, stride, count, in pointer.GetPinnableReference());
}
internal static extern void glVertexPointer(Int32 size, VertexPointerType type, Int32 stride, IntPtr pointer);
public static void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
if (glHasBufferObjects || currentArrayBufferIndex == 0)
{
OpenTK.Graphics.OpenGL.GL.VertexPointer(size, (OpenTK.Graphics.OpenGL.VertexPointerType)type, stride, pointer);
}
else
{
unsafe
{
fixed (byte* buffer = bufferData[currentArrayBufferIndex])
{
OpenTK.Graphics.OpenGL.GL.VertexPointer(size, (OpenTK.Graphics.OpenGL.VertexPointerType)type, stride, new IntPtr(&buffer[(int)pointer]));
}
}
}
}
#else
if (glHasBufferObjects || currentArrayBufferIndex == 0)
{
OpenTK.Graphics.ES11.GL.VertexPointer(size, (OpenTK.Graphics.ES11.All)type, stride, pointer);
}
else
{
unsafe
{
fixed (byte* buffer = bufferData[currentArrayBufferIndex])
{
OpenTK.Graphics.ES11.GL.VertexPointer(size, (OpenTK.Graphics.ES11.All)type, stride, new IntPtr(&buffer[(int)pointer]));
}
}
}
#endif
}
public static void VertexPointer(int size, VertexPointerType type, int stride, int offset)
{
VertexPointer(size, type, stride, (IntPtr)offset);
}
public abstract void VertexFormat([Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexPointerType type, [Flow(FlowDirection.In)] uint stride);
public abstract unsafe void ColorPointer([Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexPointerType type, [Count(Count = 4), Flow(FlowDirection.In)] void **pointer);
public static unsafe extern void VertexPointervINTEL( int size, VertexPointerType type, void** pointer );
public static void VertexArrayVertexOffsetEXT(UInt32 vaobj, UInt32 buffer, Int32 size, VertexPointerType type, Int32 stride, IntPtr offset)
{
Debug.Assert(Delegates.pglVertexArrayVertexOffsetEXT != null, "pglVertexArrayVertexOffsetEXT not implemented");
Delegates.pglVertexArrayVertexOffsetEXT(vaobj, buffer, size, (Int32)type, stride, offset);
CallLog("glVertexArrayVertexOffsetEXT({0}, {1}, {2}, {3}, {4}, 0x{5})", vaobj, buffer, size, type, stride, offset.ToString("X8"));
DebugCheckErrors();
}
public static unsafe void VertexP4(this ArbVertexType2101010Rev thisApi, [Flow(FlowDirection.In)] VertexPointerType type, [Count(Count = 1), Flow(FlowDirection.In)] ReadOnlySpan <uint> value)
{
// SpanOverloader
thisApi.VertexP4(type, in value.GetPinnableReference());
}
public static void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
{
gl.glVertexPointer(size, (int)type, stride, pointer);
}