mirror of
https://github.com/Ryujinx/Opentk.git
synced 2025-05-04 15:22:11 +00:00
64032 lines
2.5 MiB
64032 lines
2.5 MiB
namespace OpenTK.OpenGL
|
|
{
|
|
using System;
|
|
|
|
using GLsizei = System.Int32;
|
|
using GLsizeiptr = System.IntPtr;
|
|
using GLintptr = System.IntPtr;
|
|
using GLboolean = System.Boolean;
|
|
using GLbitfield = System.UInt32;
|
|
using GLchar = System.Char;
|
|
using GLbyte = System.SByte;
|
|
using GLubyte = System.Byte;
|
|
using GLshort = System.Int16;
|
|
using GLushort = System.UInt16;
|
|
using GLint = System.Int32;
|
|
using GLuint = System.UInt32;
|
|
using GLfloat = System.Single;
|
|
using GLclampf = System.Single;
|
|
using GLdouble = System.Double;
|
|
using GLclampd = System.Double;
|
|
using GLstring = System.String;
|
|
using GLsizeiptrARB = System.IntPtr;
|
|
using GLintptrARB = System.IntPtr;
|
|
using GLhandleARB = System.UInt32;
|
|
using GLhalfARB = System.UInt16;
|
|
using GLhalfNV = System.UInt16;
|
|
using GLcharARB = System.Char;
|
|
using GLint64EXT = System.Int64;
|
|
using GLuint64EXT = System.UInt64;
|
|
using GLint64 = System.Int64;
|
|
using GLuint64 = System.UInt64;
|
|
|
|
public static partial class GL
|
|
{
|
|
static GL() { }
|
|
|
|
public static
|
|
void NewList(Int32 list, GL.Enums.ListMode mode)
|
|
{
|
|
Delegates.glNewList((GLuint)list, (GL.Enums.ListMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NewList(GLuint list, GL.Enums.ListMode mode)
|
|
{
|
|
Delegates.glNewList((GLuint)list, (GL.Enums.ListMode)mode);
|
|
}
|
|
|
|
public static
|
|
void EndList()
|
|
{
|
|
Delegates.glEndList();
|
|
}
|
|
|
|
public static
|
|
void CallList(Int32 list)
|
|
{
|
|
Delegates.glCallList((GLuint)list);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CallList(GLuint list)
|
|
{
|
|
Delegates.glCallList((GLuint)list);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CallLists(GLsizei n, GL.Enums.ListNameType type, void* lists)
|
|
{
|
|
unsafe { Delegates.glCallLists((GLsizei)n, (GL.Enums.ListNameType)type, (void*)lists); }
|
|
}
|
|
|
|
public static
|
|
void CallLists(GLsizei n, GL.Enums.ListNameType type, object lists)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle lists_ptr = System.Runtime.InteropServices.GCHandle.Alloc(lists, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCallLists((GLsizei)n, (GL.Enums.ListNameType)type, (void*)lists_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
lists_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteLists(Int32 list, GLsizei range)
|
|
{
|
|
Delegates.glDeleteLists((GLuint)list, (GLsizei)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteLists(GLuint list, GLsizei range)
|
|
{
|
|
Delegates.glDeleteLists((GLuint)list, (GLsizei)range);
|
|
}
|
|
|
|
public static
|
|
Int32 GenLists(GLsizei range)
|
|
{
|
|
return Delegates.glGenLists((GLsizei)range);
|
|
}
|
|
|
|
public static
|
|
void ListBase(Int32 @base)
|
|
{
|
|
Delegates.glListBase((GLuint)@base);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListBase(GLuint @base)
|
|
{
|
|
Delegates.glListBase((GLuint)@base);
|
|
}
|
|
|
|
public static
|
|
void Begin(GL.Enums.BeginMode mode)
|
|
{
|
|
Delegates.glBegin((GL.Enums.BeginMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte* bitmap)
|
|
{
|
|
unsafe { Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap); }
|
|
}
|
|
|
|
public static
|
|
void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte[] bitmap)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* bitmap_ptr = bitmap)
|
|
{
|
|
Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, ref GLubyte bitmap)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* bitmap_ptr = &bitmap)
|
|
{
|
|
Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3b(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3b(GLbyte red, GLbyte green, GLbyte blue)
|
|
{
|
|
Delegates.glColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glColor3bv((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glColor3bv((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3d(GLdouble red, GLdouble green, GLdouble blue)
|
|
{
|
|
Delegates.glColor3d((GLdouble)red, (GLdouble)green, (GLdouble)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glColor3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glColor3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3f(GLfloat red, GLfloat green, GLfloat blue)
|
|
{
|
|
Delegates.glColor3f((GLfloat)red, (GLfloat)green, (GLfloat)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3i(GLint red, GLint green, GLint blue)
|
|
{
|
|
Delegates.glColor3i((GLint)red, (GLint)green, (GLint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glColor3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glColor3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3s(GLshort red, GLshort green, GLshort blue)
|
|
{
|
|
Delegates.glColor3s((GLshort)red, (GLshort)green, (GLshort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glColor3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glColor3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3ub(GLubyte red, GLubyte green, GLubyte blue)
|
|
{
|
|
Delegates.glColor3ub((GLubyte)red, (GLubyte)green, (GLubyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3ubv(GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glColor3ubv((GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3ubv(GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glColor3ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3ubv(ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3ui(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3ui(GLuint red, GLuint green, GLuint blue)
|
|
{
|
|
Delegates.glColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3uiv(Int32* v)
|
|
{
|
|
{
|
|
Delegates.glColor3uiv((GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3uiv(GLuint* v)
|
|
{
|
|
unsafe { Delegates.glColor3uiv((GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3uiv(Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3uiv(GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3uiv(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3uiv(ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3us(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3us(GLushort red, GLushort green, GLushort blue)
|
|
{
|
|
Delegates.glColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3usv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor3usv((GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3usv(GLushort* v)
|
|
{
|
|
unsafe { Delegates.glColor3usv((GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3usv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3usv(GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3usv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3usv(ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4b(Byte red, Byte green, Byte blue, Byte alpha)
|
|
{
|
|
Delegates.glColor4b((GLbyte)red, (GLbyte)green, (GLbyte)blue, (GLbyte)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
|
|
{
|
|
Delegates.glColor4b((GLbyte)red, (GLbyte)green, (GLbyte)blue, (GLbyte)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glColor4bv((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glColor4bv((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glColor4bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glColor4bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
|
|
{
|
|
Delegates.glColor4d((GLdouble)red, (GLdouble)green, (GLdouble)blue, (GLdouble)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glColor4dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glColor4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
Delegates.glColor4f((GLfloat)red, (GLfloat)green, (GLfloat)blue, (GLfloat)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor4fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4i(GLint red, GLint green, GLint blue, GLint alpha)
|
|
{
|
|
Delegates.glColor4i((GLint)red, (GLint)green, (GLint)blue, (GLint)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glColor4iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glColor4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
|
|
{
|
|
Delegates.glColor4s((GLshort)red, (GLshort)green, (GLshort)blue, (GLshort)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glColor4sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glColor4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
|
{
|
|
Delegates.glColor4ub((GLubyte)red, (GLubyte)green, (GLubyte)blue, (GLubyte)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubv(GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glColor4ubv((GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4ubv(GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubv(ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ui(Int32 red, Int32 green, Int32 blue, Int32 alpha)
|
|
{
|
|
Delegates.glColor4ui((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
|
|
{
|
|
Delegates.glColor4ui((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4uiv(Int32* v)
|
|
{
|
|
{
|
|
Delegates.glColor4uiv((GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4uiv(GLuint* v)
|
|
{
|
|
unsafe { Delegates.glColor4uiv((GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4uiv(Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glColor4uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4uiv(GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glColor4uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4uiv(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4uiv(ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4us(Int16 red, Int16 green, Int16 blue, Int16 alpha)
|
|
{
|
|
Delegates.glColor4us((GLushort)red, (GLushort)green, (GLushort)blue, (GLushort)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
|
|
{
|
|
Delegates.glColor4us((GLushort)red, (GLushort)green, (GLushort)blue, (GLushort)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4usv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor4usv((GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4usv(GLushort* v)
|
|
{
|
|
unsafe { Delegates.glColor4usv((GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4usv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4usv(GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glColor4usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4usv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4usv(ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EdgeFlag(GL.Enums.Boolean flag)
|
|
{
|
|
Delegates.glEdgeFlag((GL.Enums.Boolean)flag);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagv(GL.Enums.Boolean* flag)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagv((GL.Enums.Boolean*)flag); }
|
|
}
|
|
|
|
public static
|
|
void End()
|
|
{
|
|
Delegates.glEnd();
|
|
}
|
|
|
|
public static
|
|
void Indexd(GLdouble c)
|
|
{
|
|
Delegates.glIndexd((GLdouble)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexdv(GLdouble* c)
|
|
{
|
|
unsafe { Delegates.glIndexdv((GLdouble*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexdv(GLdouble[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* c_ptr = c)
|
|
{
|
|
Delegates.glIndexdv((GLdouble*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexdv(ref GLdouble c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexdv((GLdouble*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexf(GLfloat c)
|
|
{
|
|
Delegates.glIndexf((GLfloat)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexfv(GLfloat* c)
|
|
{
|
|
unsafe { Delegates.glIndexfv((GLfloat*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexfv(GLfloat[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glIndexfv((GLfloat*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexfv(ref GLfloat c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexfv((GLfloat*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexi(GLint c)
|
|
{
|
|
Delegates.glIndexi((GLint)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexiv(GLint* c)
|
|
{
|
|
unsafe { Delegates.glIndexiv((GLint*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexiv(GLint[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* c_ptr = c)
|
|
{
|
|
Delegates.glIndexiv((GLint*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexiv(ref GLint c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexiv((GLint*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexs(GLshort c)
|
|
{
|
|
Delegates.glIndexs((GLshort)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexsv(GLshort* c)
|
|
{
|
|
unsafe { Delegates.glIndexsv((GLshort*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexsv(GLshort[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* c_ptr = c)
|
|
{
|
|
Delegates.glIndexsv((GLshort*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexsv(ref GLshort c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexsv((GLshort*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3b(Byte nx, Byte ny, Byte nz)
|
|
{
|
|
Delegates.glNormal3b((GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
|
|
{
|
|
Delegates.glNormal3b((GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glNormal3bv((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glNormal3bv((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
|
|
{
|
|
Delegates.glNormal3d((GLdouble)nx, (GLdouble)ny, (GLdouble)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glNormal3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
|
|
{
|
|
Delegates.glNormal3f((GLfloat)nx, (GLfloat)ny, (GLfloat)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glNormal3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3i(GLint nx, GLint ny, GLint nz)
|
|
{
|
|
Delegates.glNormal3i((GLint)nx, (GLint)ny, (GLint)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glNormal3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3s(GLshort nx, GLshort ny, GLshort nz)
|
|
{
|
|
Delegates.glNormal3s((GLshort)nx, (GLshort)ny, (GLshort)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glNormal3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glRasterPos2d((GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glRasterPos2f((GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2i(GLint x, GLint y)
|
|
{
|
|
Delegates.glRasterPos2i((GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2s(GLshort x, GLshort y)
|
|
{
|
|
Delegates.glRasterPos2s((GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glRasterPos3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glRasterPos3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glRasterPos3i((GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glRasterPos3s((GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glRasterPos4d((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glRasterPos4f((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glRasterPos4i((GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glRasterPos4s((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
|
|
{
|
|
Delegates.glRectd((GLdouble)x1, (GLdouble)y1, (GLdouble)x2, (GLdouble)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectdv(GLdouble* v1, GLdouble* v2)
|
|
{
|
|
unsafe { Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectdv(GLdouble* v1, GLdouble[] v2)
|
|
{
|
|
fixed (GLdouble* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectdv(GLdouble* v1, ref GLdouble v2)
|
|
{
|
|
fixed (GLdouble* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectdv(GLdouble[] v1, GLdouble* v2)
|
|
{
|
|
fixed (GLdouble* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectdv(GLdouble[] v1, GLdouble[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v1_ptr = v1)
|
|
fixed (GLdouble* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectdv(GLdouble[] v1, ref GLdouble v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v1_ptr = v1)
|
|
fixed (GLdouble* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectdv(ref GLdouble v1, GLdouble* v2)
|
|
{
|
|
fixed (GLdouble* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectdv(ref GLdouble v1, GLdouble[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v1_ptr = &v1)
|
|
fixed (GLdouble* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectdv(ref GLdouble v1, ref GLdouble v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v1_ptr = &v1)
|
|
fixed (GLdouble* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
|
|
{
|
|
Delegates.glRectf((GLfloat)x1, (GLfloat)y1, (GLfloat)x2, (GLfloat)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectfv(GLfloat* v1, GLfloat* v2)
|
|
{
|
|
unsafe { Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectfv(GLfloat* v1, GLfloat[] v2)
|
|
{
|
|
fixed (GLfloat* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectfv(GLfloat* v1, ref GLfloat v2)
|
|
{
|
|
fixed (GLfloat* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectfv(GLfloat[] v1, GLfloat* v2)
|
|
{
|
|
fixed (GLfloat* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectfv(GLfloat[] v1, GLfloat[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v1_ptr = v1)
|
|
fixed (GLfloat* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectfv(GLfloat[] v1, ref GLfloat v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v1_ptr = v1)
|
|
fixed (GLfloat* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectfv(ref GLfloat v1, GLfloat* v2)
|
|
{
|
|
fixed (GLfloat* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectfv(ref GLfloat v1, GLfloat[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v1_ptr = &v1)
|
|
fixed (GLfloat* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectfv(ref GLfloat v1, ref GLfloat v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v1_ptr = &v1)
|
|
fixed (GLfloat* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Recti(GLint x1, GLint y1, GLint x2, GLint y2)
|
|
{
|
|
Delegates.glRecti((GLint)x1, (GLint)y1, (GLint)x2, (GLint)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectiv(GLint* v1, GLint* v2)
|
|
{
|
|
unsafe { Delegates.glRectiv((GLint*)v1, (GLint*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectiv(GLint* v1, GLint[] v2)
|
|
{
|
|
fixed (GLint* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectiv(GLint* v1, ref GLint v2)
|
|
{
|
|
fixed (GLint* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectiv(GLint[] v1, GLint* v2)
|
|
{
|
|
fixed (GLint* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectiv(GLint[] v1, GLint[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v1_ptr = v1)
|
|
fixed (GLint* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectiv(GLint[] v1, ref GLint v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v1_ptr = v1)
|
|
fixed (GLint* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectiv(ref GLint v1, GLint* v2)
|
|
{
|
|
fixed (GLint* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectiv(ref GLint v1, GLint[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v1_ptr = &v1)
|
|
fixed (GLint* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectiv(ref GLint v1, ref GLint v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v1_ptr = &v1)
|
|
fixed (GLint* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
|
|
{
|
|
Delegates.glRects((GLshort)x1, (GLshort)y1, (GLshort)x2, (GLshort)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectsv(GLshort* v1, GLshort* v2)
|
|
{
|
|
unsafe { Delegates.glRectsv((GLshort*)v1, (GLshort*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectsv(GLshort* v1, GLshort[] v2)
|
|
{
|
|
fixed (GLshort* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectsv(GLshort* v1, ref GLshort v2)
|
|
{
|
|
fixed (GLshort* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectsv(GLshort[] v1, GLshort* v2)
|
|
{
|
|
fixed (GLshort* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectsv(GLshort[] v1, GLshort[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v1_ptr = v1)
|
|
fixed (GLshort* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectsv(GLshort[] v1, ref GLshort v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v1_ptr = v1)
|
|
fixed (GLshort* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectsv(ref GLshort v1, GLshort* v2)
|
|
{
|
|
fixed (GLshort* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectsv(ref GLshort v1, GLshort[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v1_ptr = &v1)
|
|
fixed (GLshort* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectsv(ref GLshort v1, ref GLshort v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v1_ptr = &v1)
|
|
fixed (GLshort* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1d(GLdouble s)
|
|
{
|
|
Delegates.glTexCoord1d((GLdouble)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1f(GLfloat s)
|
|
{
|
|
Delegates.glTexCoord1f((GLfloat)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1i(GLint s)
|
|
{
|
|
Delegates.glTexCoord1i((GLint)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1s(GLshort s)
|
|
{
|
|
Delegates.glTexCoord1s((GLshort)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2d(GLdouble s, GLdouble t)
|
|
{
|
|
Delegates.glTexCoord2d((GLdouble)s, (GLdouble)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2f(GLfloat s, GLfloat t)
|
|
{
|
|
Delegates.glTexCoord2f((GLfloat)s, (GLfloat)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2i(GLint s, GLint t)
|
|
{
|
|
Delegates.glTexCoord2i((GLint)s, (GLint)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2s(GLshort s, GLshort t)
|
|
{
|
|
Delegates.glTexCoord2s((GLshort)s, (GLshort)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
Delegates.glTexCoord3d((GLdouble)s, (GLdouble)t, (GLdouble)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
Delegates.glTexCoord3f((GLfloat)s, (GLfloat)t, (GLfloat)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3i(GLint s, GLint t, GLint r)
|
|
{
|
|
Delegates.glTexCoord3i((GLint)s, (GLint)t, (GLint)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3s(GLshort s, GLshort t, GLshort r)
|
|
{
|
|
Delegates.glTexCoord3s((GLshort)s, (GLshort)t, (GLshort)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
Delegates.glTexCoord4d((GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
Delegates.glTexCoord4f((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4i(GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
Delegates.glTexCoord4i((GLint)s, (GLint)t, (GLint)r, (GLint)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
Delegates.glTexCoord4s((GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2d(GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertex2d((GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertex2dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2f(GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertex2f((GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertex2fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2i(GLint x, GLint y)
|
|
{
|
|
Delegates.glVertex2i((GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertex2iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2s(GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertex2s((GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertex2sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertex3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertex3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertex3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3i(GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glVertex3i((GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertex3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertex3s((GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertex3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertex4d((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertex4dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertex4f((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertex4fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glVertex4i((GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertex4iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertex4s((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertex4sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ClipPlane(GL.Enums.ClipPlaneName plane, GLdouble* equation)
|
|
{
|
|
unsafe { Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation); }
|
|
}
|
|
|
|
public static
|
|
void ClipPlane(GL.Enums.ClipPlaneName plane, GLdouble[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = equation)
|
|
{
|
|
Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClipPlane(GL.Enums.ClipPlaneName plane, ref GLdouble equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = &equation)
|
|
{
|
|
Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorMaterial(GL.Enums.MaterialFace face, GL.Enums.ColorMaterialParameter mode)
|
|
{
|
|
Delegates.glColorMaterial((GL.Enums.MaterialFace)face, (GL.Enums.ColorMaterialParameter)mode);
|
|
}
|
|
|
|
public static
|
|
void CullFace(GL.Enums.CullFaceMode mode)
|
|
{
|
|
Delegates.glCullFace((GL.Enums.CullFaceMode)mode);
|
|
}
|
|
|
|
public static
|
|
void Fogf(GL.Enums.FogParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glFogf((GL.Enums.FogParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Fogfv(GL.Enums.FogParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Fogfv(GL.Enums.FogParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogfv(GL.Enums.FogParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogi(GL.Enums.FogParameter pname, GLint param)
|
|
{
|
|
Delegates.glFogi((GL.Enums.FogParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Fogiv(GL.Enums.FogParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Fogiv(GL.Enums.FogParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogiv(GL.Enums.FogParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FrontFace(GL.Enums.FrontFaceDirection mode)
|
|
{
|
|
Delegates.glFrontFace((GL.Enums.FrontFaceDirection)mode);
|
|
}
|
|
|
|
public static
|
|
void Hint(GL.Enums.HintTarget target, GL.Enums.HintMode mode)
|
|
{
|
|
Delegates.glHint((GL.Enums.HintTarget)target, (GL.Enums.HintMode)mode);
|
|
}
|
|
|
|
public static
|
|
void Lightf(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glLightf((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lighti(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint param)
|
|
{
|
|
Delegates.glLighti((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModelf(GL.Enums.LightModelParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glLightModelf((GL.Enums.LightModelParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LightModelfv(GL.Enums.LightModelParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void LightModelfv(GL.Enums.LightModelParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModelfv(GL.Enums.LightModelParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModeli(GL.Enums.LightModelParameter pname, GLint param)
|
|
{
|
|
Delegates.glLightModeli((GL.Enums.LightModelParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LightModeliv(GL.Enums.LightModelParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void LightModeliv(GL.Enums.LightModelParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModeliv(GL.Enums.LightModelParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LineStipple(GLint factor, Int16 pattern)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glLineStipple((GLint)factor, (GLushort)pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LineStipple(GLint factor, GLushort pattern)
|
|
{
|
|
Delegates.glLineStipple((GLint)factor, (GLushort)pattern);
|
|
}
|
|
|
|
public static
|
|
void LineWidth(GLfloat width)
|
|
{
|
|
Delegates.glLineWidth((GLfloat)width);
|
|
}
|
|
|
|
public static
|
|
void Materialf(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glMaterialf((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materiali(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint param)
|
|
{
|
|
Delegates.glMateriali((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointSize(GLfloat size)
|
|
{
|
|
Delegates.glPointSize((GLfloat)size);
|
|
}
|
|
|
|
public static
|
|
void PolygonMode(GL.Enums.MaterialFace face, GL.Enums.PolygonMode mode)
|
|
{
|
|
Delegates.glPolygonMode((GL.Enums.MaterialFace)face, (GL.Enums.PolygonMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PolygonStipple(GLubyte* mask)
|
|
{
|
|
unsafe { Delegates.glPolygonStipple((GLubyte*)mask); }
|
|
}
|
|
|
|
public static
|
|
void PolygonStipple(GLubyte[] mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* mask_ptr = mask)
|
|
{
|
|
Delegates.glPolygonStipple((GLubyte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PolygonStipple(ref GLubyte mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* mask_ptr = &mask)
|
|
{
|
|
Delegates.glPolygonStipple((GLubyte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glScissor((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
public static
|
|
void ShadeModel(GL.Enums.ShadingModel mode)
|
|
{
|
|
Delegates.glShadeModel((GL.Enums.ShadingModel)mode);
|
|
}
|
|
|
|
public static
|
|
void TexParameterf(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat param)
|
|
{
|
|
Delegates.glTexParameterf((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameteri(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint param)
|
|
{
|
|
Delegates.glTexParameteri((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage1D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage1D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage2D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage2D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvf(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glTexEnvf((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvi(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint param)
|
|
{
|
|
Delegates.glTexEnvi((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGend(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble param)
|
|
{
|
|
Delegates.glTexGend((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLdouble @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenf(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glTexGenf((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGeni(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint param)
|
|
{
|
|
Delegates.glTexGeni((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, GLfloat* buffer)
|
|
{
|
|
unsafe { Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer); }
|
|
}
|
|
|
|
public static
|
|
void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, GLfloat[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, out GLfloat buffer)
|
|
{
|
|
buffer = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SelectBuffer(GLsizei size, Int32* buffer)
|
|
{
|
|
buffer = default(Int32*);
|
|
{
|
|
Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SelectBuffer(GLsizei size, GLuint* buffer)
|
|
{
|
|
unsafe { Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer); }
|
|
}
|
|
|
|
public static
|
|
void SelectBuffer(GLsizei size, Int32[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SelectBuffer(GLsizei size, GLuint[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SelectBuffer(GLsizei size, out Int32 buffer)
|
|
{
|
|
buffer = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SelectBuffer(GLsizei size, out GLuint buffer)
|
|
{
|
|
buffer = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint RenderMode(GL.Enums.RenderingMode mode)
|
|
{
|
|
return Delegates.glRenderMode((GL.Enums.RenderingMode)mode);
|
|
}
|
|
|
|
public static
|
|
void InitNames()
|
|
{
|
|
Delegates.glInitNames();
|
|
}
|
|
|
|
public static
|
|
void LoadName(Int32 name)
|
|
{
|
|
Delegates.glLoadName((GLuint)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadName(GLuint name)
|
|
{
|
|
Delegates.glLoadName((GLuint)name);
|
|
}
|
|
|
|
public static
|
|
void PassThrough(GLfloat token)
|
|
{
|
|
Delegates.glPassThrough((GLfloat)token);
|
|
}
|
|
|
|
public static
|
|
void PopName()
|
|
{
|
|
Delegates.glPopName();
|
|
}
|
|
|
|
public static
|
|
void PushName(Int32 name)
|
|
{
|
|
Delegates.glPushName((GLuint)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PushName(GLuint name)
|
|
{
|
|
Delegates.glPushName((GLuint)name);
|
|
}
|
|
|
|
public static
|
|
void DrawBuffer(GL.Enums.DrawBufferMode mode)
|
|
{
|
|
Delegates.glDrawBuffer((GL.Enums.DrawBufferMode)mode);
|
|
}
|
|
|
|
public static
|
|
void Clear(GL.Enums.ClearBufferMask mask)
|
|
{
|
|
Delegates.glClear((GL.Enums.ClearBufferMask)mask);
|
|
}
|
|
|
|
public static
|
|
void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
Delegates.glClearAccum((GLfloat)red, (GLfloat)green, (GLfloat)blue, (GLfloat)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearIndex(GLfloat c)
|
|
{
|
|
Delegates.glClearIndex((GLfloat)c);
|
|
}
|
|
|
|
public static
|
|
void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
|
|
{
|
|
Delegates.glClearColor((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearStencil(GLint s)
|
|
{
|
|
Delegates.glClearStencil((GLint)s);
|
|
}
|
|
|
|
public static
|
|
void ClearDepth(GLclampd depth)
|
|
{
|
|
Delegates.glClearDepth((GLclampd)depth);
|
|
}
|
|
|
|
public static
|
|
void StencilMask(Int32 mask)
|
|
{
|
|
Delegates.glStencilMask((GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilMask(GLuint mask)
|
|
{
|
|
Delegates.glStencilMask((GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void ColorMask(GL.Enums.Boolean red, GL.Enums.Boolean green, GL.Enums.Boolean blue, GL.Enums.Boolean alpha)
|
|
{
|
|
Delegates.glColorMask((GL.Enums.Boolean)red, (GL.Enums.Boolean)green, (GL.Enums.Boolean)blue, (GL.Enums.Boolean)alpha);
|
|
}
|
|
|
|
public static
|
|
void DepthMask(GL.Enums.Boolean flag)
|
|
{
|
|
Delegates.glDepthMask((GL.Enums.Boolean)flag);
|
|
}
|
|
|
|
public static
|
|
void IndexMask(Int32 mask)
|
|
{
|
|
Delegates.glIndexMask((GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void IndexMask(GLuint mask)
|
|
{
|
|
Delegates.glIndexMask((GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void Accum(GL.Enums.AccumOp op, GLfloat value)
|
|
{
|
|
Delegates.glAccum((GL.Enums.AccumOp)op, (GLfloat)value);
|
|
}
|
|
|
|
public static
|
|
void Disable(GL.Enums.EnableCap cap)
|
|
{
|
|
Delegates.glDisable((GL.Enums.EnableCap)cap);
|
|
}
|
|
|
|
public static
|
|
void Enable(GL.Enums.EnableCap cap)
|
|
{
|
|
Delegates.glEnable((GL.Enums.EnableCap)cap);
|
|
}
|
|
|
|
public static
|
|
void Finish()
|
|
{
|
|
Delegates.glFinish();
|
|
}
|
|
|
|
public static
|
|
void Flush()
|
|
{
|
|
Delegates.glFlush();
|
|
}
|
|
|
|
public static
|
|
void PopAttrib()
|
|
{
|
|
Delegates.glPopAttrib();
|
|
}
|
|
|
|
public static
|
|
void PushAttrib(GL.Enums.AttribMask mask)
|
|
{
|
|
Delegates.glPushAttrib((GL.Enums.AttribMask)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points)
|
|
{
|
|
unsafe { Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = points)
|
|
{
|
|
Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, ref GLdouble points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = &points)
|
|
{
|
|
Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points)
|
|
{
|
|
unsafe { Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = points)
|
|
{
|
|
Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, ref GLdouble points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = &points)
|
|
{
|
|
Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
|
|
{
|
|
Delegates.glMapGrid1d((GLint)un, (GLdouble)u1, (GLdouble)u2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
|
|
{
|
|
Delegates.glMapGrid1f((GLint)un, (GLfloat)u1, (GLfloat)u2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
|
|
{
|
|
Delegates.glMapGrid2d((GLint)un, (GLdouble)u1, (GLdouble)u2, (GLint)vn, (GLdouble)v1, (GLdouble)v2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
|
|
{
|
|
Delegates.glMapGrid2f((GLint)un, (GLfloat)u1, (GLfloat)u2, (GLint)vn, (GLfloat)v1, (GLfloat)v2);
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1d(GLdouble u)
|
|
{
|
|
Delegates.glEvalCoord1d((GLdouble)u);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord1dv(GLdouble* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord1dv((GLdouble*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1dv(GLdouble[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord1dv((GLdouble*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1dv(ref GLdouble u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord1dv((GLdouble*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1f(GLfloat u)
|
|
{
|
|
Delegates.glEvalCoord1f((GLfloat)u);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord1fv(GLfloat* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord1fv((GLfloat*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1fv(GLfloat[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord1fv((GLfloat*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1fv(ref GLfloat u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord1fv((GLfloat*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2d(GLdouble u, GLdouble v)
|
|
{
|
|
Delegates.glEvalCoord2d((GLdouble)u, (GLdouble)v);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord2dv(GLdouble* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord2dv((GLdouble*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2dv(GLdouble[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord2dv((GLdouble*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2dv(ref GLdouble u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord2dv((GLdouble*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2f(GLfloat u, GLfloat v)
|
|
{
|
|
Delegates.glEvalCoord2f((GLfloat)u, (GLfloat)v);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord2fv(GLfloat* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord2fv((GLfloat*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2fv(GLfloat[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord2fv((GLfloat*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2fv(ref GLfloat u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord2fv((GLfloat*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalMesh1(GL.Enums.MeshMode1 mode, GLint i1, GLint i2)
|
|
{
|
|
Delegates.glEvalMesh1((GL.Enums.MeshMode1)mode, (GLint)i1, (GLint)i2);
|
|
}
|
|
|
|
public static
|
|
void EvalPoint1(GLint i)
|
|
{
|
|
Delegates.glEvalPoint1((GLint)i);
|
|
}
|
|
|
|
public static
|
|
void EvalMesh2(GL.Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2)
|
|
{
|
|
Delegates.glEvalMesh2((GL.Enums.MeshMode2)mode, (GLint)i1, (GLint)i2, (GLint)j1, (GLint)j2);
|
|
}
|
|
|
|
public static
|
|
void EvalPoint2(GLint i, GLint j)
|
|
{
|
|
Delegates.glEvalPoint2((GLint)i, (GLint)j);
|
|
}
|
|
|
|
public static
|
|
void AlphaFunc(GL.Enums.AlphaFunction func, GLclampf @ref)
|
|
{
|
|
Delegates.glAlphaFunc((GL.Enums.AlphaFunction)func, (GLclampf)@ref);
|
|
}
|
|
|
|
public static
|
|
void BlendFunc(GL.Enums.BlendingFactorSrc sfactor, GL.Enums.BlendingFactorDest dfactor)
|
|
{
|
|
Delegates.glBlendFunc((GL.Enums.BlendingFactorSrc)sfactor, (GL.Enums.BlendingFactorDest)dfactor);
|
|
}
|
|
|
|
public static
|
|
void LogicOp(GL.Enums.LogicOp opcode)
|
|
{
|
|
Delegates.glLogicOp((GL.Enums.LogicOp)opcode);
|
|
}
|
|
|
|
public static
|
|
void StencilFunc(GL.Enums.StencilFunction func, GLint @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFunc(GL.Enums.StencilFunction func, GLint @ref, GLuint mask)
|
|
{
|
|
Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilOp(GL.Enums.StencilOp fail, GL.Enums.StencilOp zfail, GL.Enums.StencilOp zpass)
|
|
{
|
|
Delegates.glStencilOp((GL.Enums.StencilOp)fail, (GL.Enums.StencilOp)zfail, (GL.Enums.StencilOp)zpass);
|
|
}
|
|
|
|
public static
|
|
void DepthFunc(GL.Enums.DepthFunction func)
|
|
{
|
|
Delegates.glDepthFunc((GL.Enums.DepthFunction)func);
|
|
}
|
|
|
|
public static
|
|
void PixelZoom(GLfloat xfactor, GLfloat yfactor)
|
|
{
|
|
Delegates.glPixelZoom((GLfloat)xfactor, (GLfloat)yfactor);
|
|
}
|
|
|
|
public static
|
|
void PixelTransferf(GL.Enums.PixelTransferParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glPixelTransferf((GL.Enums.PixelTransferParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
public static
|
|
void PixelTransferi(GL.Enums.PixelTransferParameter pname, GLint param)
|
|
{
|
|
Delegates.glPixelTransferi((GL.Enums.PixelTransferParameter)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void PixelStoref(GL.Enums.PixelStoreParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glPixelStoref((GL.Enums.PixelStoreParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
public static
|
|
void PixelStorei(GL.Enums.PixelStoreParameter pname, GLint param)
|
|
{
|
|
Delegates.glPixelStorei((GL.Enums.PixelStoreParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, GLfloat* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values); }
|
|
}
|
|
|
|
public static
|
|
void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, GLfloat[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, ref GLfloat values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, Int32* values)
|
|
{
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, GLuint* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values); }
|
|
}
|
|
|
|
public static
|
|
void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, Int32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, GLuint[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, ref Int32 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, ref GLuint values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, Int16* values)
|
|
{
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, GLushort* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values); }
|
|
}
|
|
|
|
public static
|
|
void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, Int16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, GLushort[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, ref Int16 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, ref GLushort values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReadBuffer(GL.Enums.ReadBufferMode mode)
|
|
{
|
|
Delegates.glReadBuffer((GL.Enums.ReadBufferMode)mode);
|
|
}
|
|
|
|
public static
|
|
void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelCopyType type)
|
|
{
|
|
Delegates.glCopyPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelCopyType)type);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glReadPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glReadPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawPixels(GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glDrawPixels((GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void DrawPixels(GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawPixels((GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBooleanv(GL.Enums.GetPName pname, GL.Enums.Boolean* @params)
|
|
{
|
|
unsafe { Delegates.glGetBooleanv((GL.Enums.GetPName)pname, (GL.Enums.Boolean*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetClipPlane(GL.Enums.ClipPlaneName plane, GLdouble* equation)
|
|
{
|
|
unsafe { Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation); }
|
|
}
|
|
|
|
public static
|
|
void GetClipPlane(GL.Enums.ClipPlaneName plane, GLdouble[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = equation)
|
|
{
|
|
Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetClipPlane(GL.Enums.ClipPlaneName plane, out GLdouble equation)
|
|
{
|
|
equation = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = &equation)
|
|
{
|
|
Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
|
|
equation = *equation_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetDoublev(GL.Enums.GetPName pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetDoublev(GL.Enums.GetPName pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetDoublev(GL.Enums.GetPName pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GL.Enums.GLenum GetError()
|
|
{
|
|
return Delegates.glGetError();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFloatv(GL.Enums.GetPName pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFloatv(GL.Enums.GetPName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFloatv(GL.Enums.GetPName pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerv(GL.Enums.GetPName pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetIntegerv(GL.Enums.GetPName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetIntegerv(GL.Enums.GetPName pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLdouble v)
|
|
{
|
|
v = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLfloat v)
|
|
{
|
|
v = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLint* v)
|
|
{
|
|
unsafe { Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLint v)
|
|
{
|
|
v = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapfv(GL.Enums.PixelMap map, GLfloat* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapfv(GL.Enums.PixelMap map, GLfloat[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapfv(GL.Enums.PixelMap map, out GLfloat values)
|
|
{
|
|
values = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapuiv(GL.Enums.PixelMap map, Int32* values)
|
|
{
|
|
values = default(Int32*);
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapuiv(GL.Enums.PixelMap map, GLuint* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapuiv(GL.Enums.PixelMap map, Int32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapuiv(GL.Enums.PixelMap map, GLuint[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapuiv(GL.Enums.PixelMap map, out Int32 values)
|
|
{
|
|
values = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapuiv(GL.Enums.PixelMap map, out GLuint values)
|
|
{
|
|
values = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapusv(GL.Enums.PixelMap map, Int16* values)
|
|
{
|
|
values = default(Int16*);
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapusv(GL.Enums.PixelMap map, GLushort* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapusv(GL.Enums.PixelMap map, Int16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapusv(GL.Enums.PixelMap map, GLushort[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapusv(GL.Enums.PixelMap map, out Int16 values)
|
|
{
|
|
values = default(Int16);
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapusv(GL.Enums.PixelMap map, out GLushort values)
|
|
{
|
|
values = default(GLushort);
|
|
unsafe
|
|
{
|
|
fixed (GLushort* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPolygonStipple(GLubyte* mask)
|
|
{
|
|
unsafe { Delegates.glGetPolygonStipple((GLubyte*)mask); }
|
|
}
|
|
|
|
public static
|
|
void GetPolygonStipple(GLubyte[] mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* mask_ptr = mask)
|
|
{
|
|
Delegates.glGetPolygonStipple((GLubyte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPolygonStipple(out GLubyte mask)
|
|
{
|
|
mask = default(GLubyte);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* mask_ptr = &mask)
|
|
{
|
|
Delegates.glGetPolygonStipple((GLubyte*)mask_ptr);
|
|
mask = *mask_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
System.String GetString(GL.Enums.StringName name)
|
|
{
|
|
return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(Delegates.glGetString((GL.Enums.StringName)name));
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexImage(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glGetTexImage((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void GetTexImage(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetTexImage((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsEnabled(GL.Enums.EnableCap cap)
|
|
{
|
|
return Delegates.glIsEnabled((GL.Enums.EnableCap)cap);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsList(Int32 list)
|
|
{
|
|
return Delegates.glIsList((GLuint)list);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsList(GLuint list)
|
|
{
|
|
return Delegates.glIsList((GLuint)list);
|
|
}
|
|
|
|
public static
|
|
void DepthRange(GLclampd near, GLclampd far)
|
|
{
|
|
Delegates.glDepthRange((GLclampd)near, (GLclampd)far);
|
|
}
|
|
|
|
public static
|
|
void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
Delegates.glFrustum((GLdouble)left, (GLdouble)right, (GLdouble)bottom, (GLdouble)top, (GLdouble)zNear, (GLdouble)zFar);
|
|
}
|
|
|
|
public static
|
|
void LoadIdentity()
|
|
{
|
|
Delegates.glLoadIdentity();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glLoadMatrixf((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glLoadMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glLoadMatrixd((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glLoadMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixMode(GL.Enums.MatrixMode mode)
|
|
{
|
|
Delegates.glMatrixMode((GL.Enums.MatrixMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glMultMatrixf((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glMultMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glMultMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glMultMatrixd((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glMultMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glMultMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
Delegates.glOrtho((GLdouble)left, (GLdouble)right, (GLdouble)bottom, (GLdouble)top, (GLdouble)zNear, (GLdouble)zFar);
|
|
}
|
|
|
|
public static
|
|
void PopMatrix()
|
|
{
|
|
Delegates.glPopMatrix();
|
|
}
|
|
|
|
public static
|
|
void PushMatrix()
|
|
{
|
|
Delegates.glPushMatrix();
|
|
}
|
|
|
|
public static
|
|
void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glRotated((GLdouble)angle, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
public static
|
|
void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glRotatef((GLfloat)angle, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
public static
|
|
void Scaled(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glScaled((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
public static
|
|
void Scalef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glScalef((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
public static
|
|
void Translated(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glTranslated((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
public static
|
|
void Translatef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTranslatef((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
public static
|
|
void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glViewport((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
public static
|
|
void ArrayElement(GLint i)
|
|
{
|
|
Delegates.glArrayElement((GLint)i);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DisableClientState(GL.Enums.EnableCap array)
|
|
{
|
|
Delegates.glDisableClientState((GL.Enums.EnableCap)array);
|
|
}
|
|
|
|
public static
|
|
void DrawArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count)
|
|
{
|
|
Delegates.glDrawArrays((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawElements(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.GLenum type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawElements((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.GLenum)type, (void*)indices); }
|
|
}
|
|
|
|
public static
|
|
void DrawElements(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.GLenum type, object indices)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawElements((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.GLenum)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointer(GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointer((GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void EdgeFlagPointer(GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glEdgeFlagPointer((GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EnableClientState(GL.Enums.EnableCap array)
|
|
{
|
|
Delegates.glEnableClientState((GL.Enums.EnableCap)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPointerv(GL.Enums.GetPointervPName pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glGetPointerv((GL.Enums.GetPointervPName)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPointerv(GL.Enums.GetPointervPName pname, object @params)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetPointerv((GL.Enums.GetPointervPName)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glIndexPointer((GL.Enums.IndexPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glIndexPointer((GL.Enums.IndexPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glInterleavedArrays((GL.Enums.InterleavedArrayFormat)format, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glInterleavedArrays((GL.Enums.InterleavedArrayFormat)format, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glNormalPointer((GL.Enums.NormalPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glNormalPointer((GL.Enums.NormalPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointer((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointer((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointer((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointer((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PolygonOffset(GLfloat factor, GLfloat units)
|
|
{
|
|
Delegates.glPolygonOffset((GLfloat)factor, (GLfloat)units);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
|
|
{
|
|
Delegates.glCopyTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLint)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
Delegates.glCopyTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GLint)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, Int32* textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, GLuint* textures, GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, Int32[] textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, ref Int32 textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, Int32 texture)
|
|
{
|
|
Delegates.glBindTexture((GL.Enums.TextureTarget)target, (GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, GLuint texture)
|
|
{
|
|
Delegates.glBindTexture((GL.Enums.TextureTarget)target, (GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(GLsizei n, Int32* textures)
|
|
{
|
|
{
|
|
Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(GLsizei n, GLuint* textures)
|
|
{
|
|
unsafe { Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures); }
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(GLsizei n, Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(GLsizei n, GLuint[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(GLsizei n, ref Int32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(GLsizei n, ref GLuint textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(GLsizei n, Int32* textures)
|
|
{
|
|
textures = default(Int32*);
|
|
{
|
|
Delegates.glGenTextures((GLsizei)n, (GLuint*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(GLsizei n, GLuint* textures)
|
|
{
|
|
unsafe { Delegates.glGenTextures((GLsizei)n, (GLuint*)textures); }
|
|
}
|
|
|
|
public static
|
|
void GenTextures(GLsizei n, Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(GLsizei n, GLuint[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTextures(GLsizei n, out Int32 textures)
|
|
{
|
|
textures = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(GLsizei n, out GLuint textures)
|
|
{
|
|
textures = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsTexture(Int32 texture)
|
|
{
|
|
return Delegates.glIsTexture((GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsTexture(GLuint texture)
|
|
{
|
|
return Delegates.glIsTexture((GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf* priorities)
|
|
{
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf* priorities)
|
|
{
|
|
unsafe { Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf[] priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf[] priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, ref GLclampf priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, ref GLclampf priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf* priorities)
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, Int32[] textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, GLuint[] textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf* priorities)
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref Int32 textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref GLuint textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexub(GLubyte c)
|
|
{
|
|
Delegates.glIndexub((GLubyte)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexubv(GLubyte* c)
|
|
{
|
|
unsafe { Delegates.glIndexubv((GLubyte*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexubv(GLubyte[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glIndexubv((GLubyte*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexubv(ref GLubyte c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexubv((GLubyte*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PopClientAttrib()
|
|
{
|
|
Delegates.glPopClientAttrib();
|
|
}
|
|
|
|
public static
|
|
void PushClientAttrib(GL.Enums.ClientAttribMask mask)
|
|
{
|
|
Delegates.glPushClientAttrib((GL.Enums.ClientAttribMask)mask);
|
|
}
|
|
|
|
public static
|
|
void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
|
|
{
|
|
Delegates.glBlendColor((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
|
|
}
|
|
|
|
public static
|
|
void BlendEquation(GL.Enums.VERSION_1_2 mode)
|
|
{
|
|
Delegates.glBlendEquation((GL.Enums.VERSION_1_2)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.VERSION_1_2 type, void* indices)
|
|
{
|
|
{
|
|
Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.VERSION_1_2 type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices); }
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.VERSION_1_2 type, object indices)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.VERSION_1_2 type, object indices)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void ColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glGetColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
|
|
{
|
|
unsafe { Delegates.glColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void ColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterf(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat @params)
|
|
{
|
|
Delegates.glConvolutionParameterf((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteri(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint @params)
|
|
{
|
|
Delegates.glConvolutionParameteri((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetConvolutionFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, void* span)
|
|
{
|
|
unsafe { Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, object span)
|
|
{
|
|
row = default(void*);
|
|
column = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, void* span)
|
|
{
|
|
row = default(void*);
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, object span)
|
|
{
|
|
row = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, void* span)
|
|
{
|
|
column = default(void*);
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, object span)
|
|
{
|
|
column = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, void* span)
|
|
{
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, object span)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column)
|
|
{
|
|
unsafe { Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogram(GL.Enums.VERSION_1_2 target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
|
|
{
|
|
unsafe { Delegates.glGetHistogram((GL.Enums.VERSION_1_2)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmax(GL.Enums.VERSION_1_2 target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
|
|
{
|
|
unsafe { Delegates.glGetMinmax((GL.Enums.VERSION_1_2)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Histogram(GL.Enums.VERSION_1_2 target, GLsizei width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glHistogram((GL.Enums.VERSION_1_2)target, (GLsizei)width, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink);
|
|
}
|
|
|
|
public static
|
|
void Minmax(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glMinmax((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink);
|
|
}
|
|
|
|
public static
|
|
void ResetHistogram(GL.Enums.VERSION_1_2 target)
|
|
{
|
|
Delegates.glResetHistogram((GL.Enums.VERSION_1_2)target);
|
|
}
|
|
|
|
public static
|
|
void ResetMinmax(GL.Enums.VERSION_1_2 target)
|
|
{
|
|
Delegates.glResetMinmax((GL.Enums.VERSION_1_2)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage3D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage3D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
public static
|
|
void ActiveTexture(GL.Enums.VERSION_1_3 texture)
|
|
{
|
|
Delegates.glActiveTexture((GL.Enums.VERSION_1_3)texture);
|
|
}
|
|
|
|
public static
|
|
void ClientActiveTexture(GL.Enums.VERSION_1_3 texture)
|
|
{
|
|
Delegates.glClientActiveTexture((GL.Enums.VERSION_1_3)texture);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1d(GL.Enums.VERSION_1_3 target, GLdouble s)
|
|
{
|
|
Delegates.glMultiTexCoord1d((GL.Enums.VERSION_1_3)target, (GLdouble)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1f(GL.Enums.VERSION_1_3 target, GLfloat s)
|
|
{
|
|
Delegates.glMultiTexCoord1f((GL.Enums.VERSION_1_3)target, (GLfloat)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1i(GL.Enums.VERSION_1_3 target, GLint s)
|
|
{
|
|
Delegates.glMultiTexCoord1i((GL.Enums.VERSION_1_3)target, (GLint)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1s(GL.Enums.VERSION_1_3 target, GLshort s)
|
|
{
|
|
Delegates.glMultiTexCoord1s((GL.Enums.VERSION_1_3)target, (GLshort)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t)
|
|
{
|
|
Delegates.glMultiTexCoord2d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t)
|
|
{
|
|
Delegates.glMultiTexCoord2f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2i(GL.Enums.VERSION_1_3 target, GLint s, GLint t)
|
|
{
|
|
Delegates.glMultiTexCoord2i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t)
|
|
{
|
|
Delegates.glMultiTexCoord2s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
Delegates.glMultiTexCoord3d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t, (GLdouble)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
Delegates.glMultiTexCoord3f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t, (GLfloat)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3i(GL.Enums.VERSION_1_3 target, GLint s, GLint t, GLint r)
|
|
{
|
|
Delegates.glMultiTexCoord3i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t, (GLint)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r)
|
|
{
|
|
Delegates.glMultiTexCoord3s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t, (GLshort)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
Delegates.glMultiTexCoord4d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
Delegates.glMultiTexCoord4f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4i(GL.Enums.VERSION_1_3 target, GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
Delegates.glMultiTexCoord4i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t, (GLint)r, (GLint)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
Delegates.glMultiTexCoord4s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixf((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixd((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixf((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixf((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixd((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixd((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleCoverage(GLclampf value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleCoverage((GLclampf)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, void* img)
|
|
{
|
|
unsafe { Delegates.glGetCompressedTexImage((GL.Enums.TextureTarget)target, (GLint)level, (void*)img); }
|
|
}
|
|
|
|
public static
|
|
void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, object img)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetCompressedTexImage((GL.Enums.TextureTarget)target, (GLint)level, (void*)img_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
img_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendFuncSeparate(GL.Enums.VERSION_1_4 sfactorRGB, GL.Enums.VERSION_1_4 dfactorRGB, GL.Enums.VERSION_1_4 sfactorAlpha, GL.Enums.VERSION_1_4 dfactorAlpha)
|
|
{
|
|
Delegates.glBlendFuncSeparate((GL.Enums.VERSION_1_4)sfactorRGB, (GL.Enums.VERSION_1_4)dfactorRGB, (GL.Enums.VERSION_1_4)sfactorAlpha, (GL.Enums.VERSION_1_4)dfactorAlpha);
|
|
}
|
|
|
|
public static
|
|
void FogCoordf(GLfloat coord)
|
|
{
|
|
Delegates.glFogCoordf((GLfloat)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordfv(GLfloat* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoordfv((GLfloat*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordfv(GLfloat[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoordfv((GLfloat*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordfv(ref GLfloat coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoordfv((GLfloat*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordd(GLdouble coord)
|
|
{
|
|
Delegates.glFogCoordd((GLdouble)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoorddv(GLdouble* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoorddv((GLdouble*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoorddv(GLdouble[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoorddv((GLdouble*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoorddv(ref GLdouble coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoorddv((GLdouble*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointer(GL.Enums.VERSION_1_4 type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointer((GL.Enums.VERSION_1_4)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointer(GL.Enums.VERSION_1_4 type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glFogCoordPointer((GL.Enums.VERSION_1_4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
first = default(GLint*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
first = default(GLint*);
|
|
count = default(GLsizei);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
count = default(GLsizei*);
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterf(GL.Enums.VERSION_1_4 pname, GLfloat param)
|
|
{
|
|
Delegates.glPointParameterf((GL.Enums.VERSION_1_4)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterfv(GL.Enums.VERSION_1_4 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.VERSION_1_4 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.VERSION_1_4 pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteri(GL.Enums.VERSION_1_4 pname, GLint param)
|
|
{
|
|
Delegates.glPointParameteri((GL.Enums.VERSION_1_4)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameteriv(GL.Enums.VERSION_1_4 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameteriv(GL.Enums.VERSION_1_4 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteriv(GL.Enums.VERSION_1_4 pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3b(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glSecondaryColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
|
|
{
|
|
Delegates.glSecondaryColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3bv((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3bv((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
|
|
{
|
|
Delegates.glSecondaryColor3d((GLdouble)red, (GLdouble)green, (GLdouble)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
|
|
{
|
|
Delegates.glSecondaryColor3f((GLfloat)red, (GLfloat)green, (GLfloat)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3i(GLint red, GLint green, GLint blue)
|
|
{
|
|
Delegates.glSecondaryColor3i((GLint)red, (GLint)green, (GLint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
|
|
{
|
|
Delegates.glSecondaryColor3s((GLshort)red, (GLshort)green, (GLshort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
|
|
{
|
|
Delegates.glSecondaryColor3ub((GLubyte)red, (GLubyte)green, (GLubyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3ubv(GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3ubv((GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ubv(GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ubv(ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3ubv((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ui(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
|
|
{
|
|
Delegates.glSecondaryColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3uiv(Int32* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3uiv((GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3uiv(GLuint* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3uiv((GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3uiv(Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3uiv(GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3uiv(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3uiv(ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3us(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
|
|
{
|
|
Delegates.glSecondaryColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3usv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3usv((GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3usv(GLushort* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3usv((GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3usv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3usv(GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3usv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3usv(ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glWindowPos2d((GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glWindowPos2f((GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2i(GLint x, GLint y)
|
|
{
|
|
Delegates.glWindowPos2i((GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2s(GLshort x, GLshort y)
|
|
{
|
|
Delegates.glWindowPos2s((GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glWindowPos3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dv((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dv((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glWindowPos3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fv((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fv((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glWindowPos3i((GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3iv((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3iv((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glWindowPos3s((GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3sv((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3sv((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(GLsizei n, Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenQueries((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glGenQueries((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void GenQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueries(GLsizei n, out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(GLsizei n, out GLuint ids)
|
|
{
|
|
ids = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(GLsizei n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(GLsizei n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(GLsizei n, ref GLuint ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsQuery(Int32 id)
|
|
{
|
|
return Delegates.glIsQuery((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsQuery(GLuint id)
|
|
{
|
|
return Delegates.glIsQuery((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void BeginQuery(GL.Enums.VERSION_1_5 target, Int32 id)
|
|
{
|
|
Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginQuery(GL.Enums.VERSION_1_5 target, GLuint id)
|
|
{
|
|
Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void EndQuery(GL.Enums.VERSION_1_5 target)
|
|
{
|
|
Delegates.glEndQuery((GL.Enums.VERSION_1_5)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindBuffer(GL.Enums.VERSION_1_5 target, Int32 buffer)
|
|
{
|
|
Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBuffer(GL.Enums.VERSION_1_5 target, GLuint buffer)
|
|
{
|
|
Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(GLsizei n, Int32* buffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(GLsizei n, GLuint* buffers)
|
|
{
|
|
unsafe { Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers); }
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(GLsizei n, Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(GLsizei n, GLuint[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(GLsizei n, ref Int32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(GLsizei n, ref GLuint buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(GLsizei n, Int32* buffers)
|
|
{
|
|
buffers = default(Int32*);
|
|
{
|
|
Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(GLsizei n, GLuint* buffers)
|
|
{
|
|
unsafe { Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers); }
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(GLsizei n, Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(GLsizei n, GLuint[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(GLsizei n, out Int32 buffers)
|
|
{
|
|
buffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(GLsizei n, out GLuint buffers)
|
|
{
|
|
buffers = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsBuffer(Int32 buffer)
|
|
{
|
|
return Delegates.glIsBuffer((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsBuffer(GLuint buffer)
|
|
{
|
|
return Delegates.glIsBuffer((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferData(GL.Enums.VERSION_1_5 target, GLsizeiptr size, void* data, GL.Enums.VERSION_1_5 usage)
|
|
{
|
|
unsafe { Delegates.glBufferData((GL.Enums.VERSION_1_5)target, (GLsizeiptr)size, (void*)data, (GL.Enums.VERSION_1_5)usage); }
|
|
}
|
|
|
|
public static
|
|
void BufferData(GL.Enums.VERSION_1_5 target, GLsizeiptr size, object data, GL.Enums.VERSION_1_5 usage)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glBufferData((GL.Enums.VERSION_1_5)target, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject(), (GL.Enums.VERSION_1_5)usage);
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, void* data)
|
|
{
|
|
unsafe { Delegates.glBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void BufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, void* data)
|
|
{
|
|
unsafe { Delegates.glGetBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
IntPtr MapBuffer(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 access)
|
|
{
|
|
return Delegates.glMapBuffer((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)access);
|
|
}
|
|
|
|
public static
|
|
GLboolean UnmapBuffer(GL.Enums.VERSION_1_5 target)
|
|
{
|
|
return Delegates.glUnmapBuffer((GL.Enums.VERSION_1_5)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferPointerv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferPointerv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferPointerv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, object @params)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetBufferPointerv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendEquationSeparate(GL.Enums.BlendEquationModeEXT modeRGB, GL.Enums.BlendEquationModeEXT modeAlpha)
|
|
{
|
|
Delegates.glBlendEquationSeparate((GL.Enums.BlendEquationModeEXT)modeRGB, (GL.Enums.BlendEquationModeEXT)modeAlpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawBuffers(GLsizei n, GL.Enums.VERSION_2_0* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, GL.Enums.VERSION_2_0[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.VERSION_2_0* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, ref GL.Enums.VERSION_2_0 bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.VERSION_2_0* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void StencilOpSeparate(GL.Enums.VERSION_2_0 face, GL.Enums.StencilOp sfail, GL.Enums.StencilOp dpfail, GL.Enums.StencilOp dppass)
|
|
{
|
|
Delegates.glStencilOpSeparate((GL.Enums.VERSION_2_0)face, (GL.Enums.StencilOp)sfail, (GL.Enums.StencilOp)dpfail, (GL.Enums.StencilOp)dppass);
|
|
}
|
|
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
|
|
{
|
|
Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, Int32 mask)
|
|
{
|
|
Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, GLuint mask)
|
|
{
|
|
Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void AttachShader(Int32 program, Int32 shader)
|
|
{
|
|
Delegates.glAttachShader((GLuint)program, (GLuint)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AttachShader(GLuint program, GLuint shader)
|
|
{
|
|
Delegates.glAttachShader((GLuint)program, (GLuint)shader);
|
|
}
|
|
|
|
public static
|
|
void BindAttribLocation(Int32 program, Int32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocation((GLuint)program, (GLuint)index, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindAttribLocation(GLuint program, GLuint index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocation((GLuint)program, (GLuint)index, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void CompileShader(Int32 shader)
|
|
{
|
|
Delegates.glCompileShader((GLuint)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CompileShader(GLuint shader)
|
|
{
|
|
Delegates.glCompileShader((GLuint)shader);
|
|
}
|
|
|
|
public static
|
|
Int32 CreateProgram()
|
|
{
|
|
return Delegates.glCreateProgram();
|
|
}
|
|
|
|
public static
|
|
Int32 CreateShader(GL.Enums.VERSION_2_0 type)
|
|
{
|
|
return Delegates.glCreateShader((GL.Enums.VERSION_2_0)type);
|
|
}
|
|
|
|
public static
|
|
void DeleteProgram(Int32 program)
|
|
{
|
|
Delegates.glDeleteProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgram(GLuint program)
|
|
{
|
|
Delegates.glDeleteProgram((GLuint)program);
|
|
}
|
|
|
|
public static
|
|
void DeleteShader(Int32 shader)
|
|
{
|
|
Delegates.glDeleteShader((GLuint)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteShader(GLuint shader)
|
|
{
|
|
Delegates.glDeleteShader((GLuint)shader);
|
|
}
|
|
|
|
public static
|
|
void DetachShader(Int32 program, Int32 shader)
|
|
{
|
|
Delegates.glDetachShader((GLuint)program, (GLuint)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DetachShader(GLuint program, GLuint shader)
|
|
{
|
|
Delegates.glDetachShader((GLuint)program, (GLuint)shader);
|
|
}
|
|
|
|
public static
|
|
void DisableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArray((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVertexAttribArray(GLuint index)
|
|
{
|
|
Delegates.glDisableVertexAttribArray((GLuint)index);
|
|
}
|
|
|
|
public static
|
|
void EnableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArray((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVertexAttribArray(GLuint index)
|
|
{
|
|
Delegates.glEnableVertexAttribArray((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, Int32* obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(Int32*);
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj)
|
|
{
|
|
unsafe { Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, Int32[] obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint[] obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (GLuint* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, out Int32 obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(Int32);
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, out GLuint obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(GLuint);
|
|
fixed (GLuint* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, Int32* obj)
|
|
{
|
|
obj = default(Int32*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, GLuint* obj)
|
|
{
|
|
obj = default(GLuint*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, Int32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, GLuint[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (GLuint* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, out Int32 obj)
|
|
{
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, out GLuint obj)
|
|
{
|
|
obj = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (GLuint* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, Int32* obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(Int32*);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, GLuint* obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(GLuint*);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, Int32[] obj)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, GLuint[] obj)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (GLuint* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, out Int32 obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, out GLuint obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (GLuint* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint GetAttribLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocation((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetAttribLocation(GLuint program, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocation((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramInfoLog(Int32 program, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramInfoLog(Int32 program, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramInfoLog(Int32 program, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramInfoLog(GLuint program, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderInfoLog(Int32 shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
public static
|
|
void GetShaderInfoLog(Int32 shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderInfoLog(Int32 shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderInfoLog(GLuint shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(Int32 shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei*);
|
|
source = default(System.Text.StringBuilder[]);
|
|
{
|
|
Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder[] source)
|
|
{
|
|
unsafe { Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder[])source); }
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(GLuint shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint GetUniformLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocation((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetUniformLocation(GLuint program, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocation((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformfv(Int32 program, GLint location, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformfv(GLuint program, GLint location, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetUniformfv(Int32 program, GLint location, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformfv(GLuint program, GLint location, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformfv(Int32 program, GLint location, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformfv(GLuint program, GLint location, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformiv(Int32 program, GLint location, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformiv(GLuint program, GLint location, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetUniformiv(Int32 program, GLint location, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformiv(GLuint program, GLint location, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformiv(Int32 program, GLint location, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformiv(GLuint program, GLint location, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.VERSION_2_0 pname, void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointerv(GLuint index, GL.Enums.VERSION_2_0 pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsProgram(Int32 program)
|
|
{
|
|
return Delegates.glIsProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsProgram(GLuint program)
|
|
{
|
|
return Delegates.glIsProgram((GLuint)program);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsShader(Int32 shader)
|
|
{
|
|
return Delegates.glIsShader((GLuint)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsShader(GLuint shader)
|
|
{
|
|
return Delegates.glIsShader((GLuint)shader);
|
|
}
|
|
|
|
public static
|
|
void LinkProgram(Int32 program)
|
|
{
|
|
Delegates.glLinkProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LinkProgram(GLuint program)
|
|
{
|
|
Delegates.glLinkProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, GLint* length)
|
|
{
|
|
{
|
|
Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, GLint* length)
|
|
{
|
|
unsafe { Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length); }
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, GLint[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, GLint[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, ref GLint length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, ref GLint length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void UseProgram(Int32 program)
|
|
{
|
|
Delegates.glUseProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UseProgram(GLuint program)
|
|
{
|
|
Delegates.glUseProgram((GLuint)program);
|
|
}
|
|
|
|
public static
|
|
void Uniform1f(GLint location, GLfloat v0)
|
|
{
|
|
Delegates.glUniform1f((GLint)location, (GLfloat)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2f(GLint location, GLfloat v0, GLfloat v1)
|
|
{
|
|
Delegates.glUniform2f((GLint)location, (GLfloat)v0, (GLfloat)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
|
|
{
|
|
Delegates.glUniform3f((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
|
|
{
|
|
Delegates.glUniform4f((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2, (GLfloat)v3);
|
|
}
|
|
|
|
public static
|
|
void Uniform1i(GLint location, GLint v0)
|
|
{
|
|
Delegates.glUniform1i((GLint)location, (GLint)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2i(GLint location, GLint v0, GLint v1)
|
|
{
|
|
Delegates.glUniform2i((GLint)location, (GLint)v0, (GLint)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
|
|
{
|
|
Delegates.glUniform3i((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
|
|
{
|
|
Delegates.glUniform4i((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2, (GLint)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void ValidateProgram(Int32 program)
|
|
{
|
|
Delegates.glValidateProgram((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ValidateProgram(GLuint program)
|
|
{
|
|
Delegates.glValidateProgram((GLuint)program);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1d(Int32 index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1d((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1d(GLuint index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1d((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1f(Int32 index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1f((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1f(GLuint index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1f((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1s(Int32 index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1s((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1s(GLuint index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1s((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2d((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2d((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2f((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2f((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2s((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2s((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nbv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nbv(GLuint index, GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nbv(Int32 index, Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nbv(GLuint index, GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nbv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nbv(GLuint index, ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Niv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Niv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Niv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Niv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Niv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Niv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nsv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nsv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nsv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nsv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nsv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nsv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4Nub((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4Nub((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nuiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nuiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nuiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nuiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nuiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nuiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nusv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nusv(GLuint index, GLushort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nusv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nusv(GLuint index, GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nusv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nusv(GLuint index, ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4bv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4bv(GLuint index, GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4bv(Int32 index, Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4bv(GLuint index, GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4bv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4bv(GLuint index, ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4usv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4usv(GLuint index, GLushort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4usv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4usv(GLuint index, GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4usv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4usv(GLuint index, ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(Int32 index, GLint size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointer((GLuint)index, (GLint)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(GLuint index, GLint size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointer((GLuint)index, (GLint)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2x3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2x3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3x2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3x2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2x4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2x4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4x2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4x2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3x4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3x4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4x3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4x3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointervINTEL(GL.Enums.NormalPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glNormalPointervINTEL((GL.Enums.NormalPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointervINTEL(GL.Enums.NormalPointerType type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glNormalPointervINTEL((GL.Enums.NormalPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TbufferMask3DFX(Int32 mask)
|
|
{
|
|
Delegates.glTbufferMask3DFX((GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TbufferMask3DFX(GLuint mask)
|
|
{
|
|
Delegates.glTbufferMask3DFX((GLuint)mask);
|
|
}
|
|
|
|
public static class ARB
|
|
{
|
|
public static
|
|
void ActiveTexture(GL.Enums.ARB_multitexture texture)
|
|
{
|
|
Delegates.glActiveTextureARB((GL.Enums.ARB_multitexture)texture);
|
|
}
|
|
|
|
public static
|
|
void ClientActiveTexture(GL.Enums.ARB_multitexture texture)
|
|
{
|
|
Delegates.glClientActiveTextureARB((GL.Enums.ARB_multitexture)texture);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1d(GL.Enums.ARB_multitexture target, GLdouble s)
|
|
{
|
|
Delegates.glMultiTexCoord1dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1f(GL.Enums.ARB_multitexture target, GLfloat s)
|
|
{
|
|
Delegates.glMultiTexCoord1fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1i(GL.Enums.ARB_multitexture target, GLint s)
|
|
{
|
|
Delegates.glMultiTexCoord1iARB((GL.Enums.ARB_multitexture)target, (GLint)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1s(GL.Enums.ARB_multitexture target, GLshort s)
|
|
{
|
|
Delegates.glMultiTexCoord1sARB((GL.Enums.ARB_multitexture)target, (GLshort)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t)
|
|
{
|
|
Delegates.glMultiTexCoord2dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t)
|
|
{
|
|
Delegates.glMultiTexCoord2fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2i(GL.Enums.ARB_multitexture target, GLint s, GLint t)
|
|
{
|
|
Delegates.glMultiTexCoord2iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t)
|
|
{
|
|
Delegates.glMultiTexCoord2sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
Delegates.glMultiTexCoord3dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t, (GLdouble)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
Delegates.glMultiTexCoord3fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t, (GLfloat)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3i(GL.Enums.ARB_multitexture target, GLint s, GLint t, GLint r)
|
|
{
|
|
Delegates.glMultiTexCoord3iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t, (GLint)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r)
|
|
{
|
|
Delegates.glMultiTexCoord3sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t, (GLshort)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
Delegates.glMultiTexCoord4dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
Delegates.glMultiTexCoord4fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4i(GL.Enums.ARB_multitexture target, GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
Delegates.glMultiTexCoord4iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t, (GLint)r, (GLint)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, GLint* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
Delegates.glMultiTexCoord4sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixfARB((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixfARB((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixfARB((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixdARB((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixdARB((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixdARB((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixf(GLfloat* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixfARB((GLfloat*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf(GLfloat[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixfARB((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf(ref GLfloat m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixfARB((GLfloat*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixd(GLdouble* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixdARB((GLdouble*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd(GLdouble[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixdARB((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd(ref GLdouble m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixdARB((GLdouble*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleCoverage(GLclampf value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleCoverageARB((GLclampf)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCompressedTexSubImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, void* img)
|
|
{
|
|
unsafe { Delegates.glGetCompressedTexImageARB((GL.Enums.TextureTarget)target, (GLint)level, (void*)img); }
|
|
}
|
|
|
|
public static
|
|
void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, object img)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetCompressedTexImageARB((GL.Enums.TextureTarget)target, (GLint)level, (void*)img_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
img_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterf(GL.Enums.ARB_point_parameters pname, GLfloat param)
|
|
{
|
|
Delegates.glPointParameterfARB((GL.Enums.ARB_point_parameters)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterfv(GL.Enums.ARB_point_parameters pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.ARB_point_parameters pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.ARB_point_parameters pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightbv(GLint size, Byte* weights)
|
|
{
|
|
{
|
|
Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightbv(GLint size, GLbyte* weights)
|
|
{
|
|
unsafe { Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightbv(GLint size, Byte[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightbv(GLint size, GLbyte[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightbv(GLint size, ref Byte weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightbv(GLint size, ref GLbyte weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightsv(GLint size, GLshort* weights)
|
|
{
|
|
unsafe { Delegates.glWeightsvARB((GLint)size, (GLshort*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightsv(GLint size, GLshort[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightsvARB((GLint)size, (GLshort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightsv(GLint size, ref GLshort weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightsvARB((GLint)size, (GLshort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightiv(GLint size, GLint* weights)
|
|
{
|
|
unsafe { Delegates.glWeightivARB((GLint)size, (GLint*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightiv(GLint size, GLint[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightivARB((GLint)size, (GLint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightiv(GLint size, ref GLint weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightivARB((GLint)size, (GLint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightfv(GLint size, GLfloat* weights)
|
|
{
|
|
unsafe { Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightfv(GLint size, GLfloat[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightfv(GLint size, ref GLfloat weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightdv(GLint size, GLdouble* weights)
|
|
{
|
|
unsafe { Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightdv(GLint size, GLdouble[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightdv(GLint size, ref GLdouble weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightubv(GLint size, GLubyte* weights)
|
|
{
|
|
unsafe { Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightubv(GLint size, GLubyte[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightubv(GLint size, ref GLubyte weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightusv(GLint size, Int16* weights)
|
|
{
|
|
{
|
|
Delegates.glWeightusvARB((GLint)size, (GLushort*)weights);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightusv(GLint size, GLushort* weights)
|
|
{
|
|
unsafe { Delegates.glWeightusvARB((GLint)size, (GLushort*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightusv(GLint size, Int16[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightusv(GLint size, GLushort[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightusv(GLint size, ref Int16 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightusv(GLint size, ref GLushort weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightuiv(GLint size, Int32* weights)
|
|
{
|
|
{
|
|
Delegates.glWeightuivARB((GLint)size, (GLuint*)weights);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightuiv(GLint size, GLuint* weights)
|
|
{
|
|
unsafe { Delegates.glWeightuivARB((GLint)size, (GLuint*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightuiv(GLint size, Int32[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightuiv(GLint size, GLuint[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightuiv(GLint size, ref Int32 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightuiv(GLint size, ref GLuint weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WeightPointer(GLint size, GL.Enums.ARB_vertex_blend type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glWeightPointerARB((GLint)size, (GL.Enums.ARB_vertex_blend)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void WeightPointer(GLint size, GL.Enums.ARB_vertex_blend type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glWeightPointerARB((GLint)size, (GL.Enums.ARB_vertex_blend)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexBlend(GLint count)
|
|
{
|
|
Delegates.glVertexBlendARB((GLint)count);
|
|
}
|
|
|
|
public static
|
|
void CurrentPaletteMatrix(GLint index)
|
|
{
|
|
Delegates.glCurrentPaletteMatrixARB((GLint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexubv(GLint size, GLubyte* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexubv(GLint size, GLubyte[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexubv(GLint size, ref GLubyte indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexusv(GLint size, Int16* indices)
|
|
{
|
|
{
|
|
Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexusv(GLint size, GLushort* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexusv(GLint size, Int16[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexusv(GLint size, GLushort[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexusv(GLint size, ref Int16 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexusv(GLint size, ref GLushort indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexuiv(GLint size, Int32* indices)
|
|
{
|
|
{
|
|
Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexuiv(GLint size, GLuint* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexuiv(GLint size, Int32[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexuiv(GLint size, GLuint[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexuiv(GLint size, ref Int32 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexuiv(GLint size, ref GLuint indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexPointer(GLint size, GL.Enums.ARB_matrix_palette type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexPointerARB((GLint)size, (GL.Enums.ARB_matrix_palette)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexPointer(GLint size, GL.Enums.ARB_matrix_palette type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glMatrixIndexPointerARB((GLint)size, (GL.Enums.ARB_matrix_palette)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glWindowPos2dARB((GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dvARB((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dvARB((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dvARB((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glWindowPos2fARB((GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fvARB((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fvARB((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fvARB((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2i(GLint x, GLint y)
|
|
{
|
|
Delegates.glWindowPos2iARB((GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2ivARB((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2ivARB((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2ivARB((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2s(GLshort x, GLshort y)
|
|
{
|
|
Delegates.glWindowPos2sARB((GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2svARB((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2svARB((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2svARB((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glWindowPos3dARB((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dvARB((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dvARB((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dvARB((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glWindowPos3fARB((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fvARB((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fvARB((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fvARB((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glWindowPos3iARB((GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3ivARB((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3ivARB((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3ivARB((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glWindowPos3sARB((GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3svARB((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3svARB((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3svARB((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1d(Int32 index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1dARB((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1d(GLuint index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1dARB((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1f(Int32 index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1fARB((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1f(GLuint index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1fARB((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1s(Int32 index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1sARB((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1s(GLuint index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1sARB((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2dARB((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2dARB((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2fARB((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2fARB((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2sARB((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2sARB((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nbv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nbv(GLuint index, GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nbv(Int32 index, Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nbv(GLuint index, GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nbv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nbv(GLuint index, ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Niv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Niv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Niv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Niv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Niv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Niv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nsv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nsv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nsv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nsv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nsv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nsv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4NubARB((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4NubARB((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nuiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nuiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nuiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nuiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nuiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nuiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nusv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nusv(GLuint index, GLushort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nusv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nusv(GLuint index, GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nusv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nusv(GLuint index, ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4bv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4bv(GLuint index, GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4bv(Int32 index, Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4bv(GLuint index, GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4bv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4bv(GLuint index, ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4usv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4usv(GLuint index, GLushort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4usv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4usv(GLuint index, GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4usv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4usv(GLuint index, ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(Int32 index, GLint size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointerARB((GLuint)index, (GLint)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(GLuint index, GLint size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointerARB((GLuint)index, (GLint)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void EnableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArrayARB((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVertexAttribArray(GLuint index)
|
|
{
|
|
Delegates.glEnableVertexAttribArrayARB((GLuint)index);
|
|
}
|
|
|
|
public static
|
|
void DisableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArrayARB((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVertexAttribArray(GLuint index)
|
|
{
|
|
Delegates.glDisableVertexAttribArrayARB((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, GLsizei len, void* @string)
|
|
{
|
|
unsafe { Delegates.glProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)format, (GLsizei)len, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void ProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, GLsizei len, object @string)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)format, (GLsizei)len, (void*)@string_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@string_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindProgram(GL.Enums.ARB_vertex_program target, Int32 program)
|
|
{
|
|
Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindProgram(GL.Enums.ARB_vertex_program target, GLuint program)
|
|
{
|
|
Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeletePrograms(GLsizei n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeletePrograms(GLsizei n, GLuint* programs)
|
|
{
|
|
unsafe { Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs); }
|
|
}
|
|
|
|
public static
|
|
void DeletePrograms(GLsizei n, Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeletePrograms(GLsizei n, GLuint[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeletePrograms(GLsizei n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeletePrograms(GLsizei n, ref GLuint programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenPrograms(GLsizei n, Int32* programs)
|
|
{
|
|
programs = default(Int32*);
|
|
{
|
|
Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenPrograms(GLsizei n, GLuint* programs)
|
|
{
|
|
unsafe { Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs); }
|
|
}
|
|
|
|
public static
|
|
void GenPrograms(GLsizei n, Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenPrograms(GLsizei n, GLuint[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenPrograms(GLsizei n, out Int32 programs)
|
|
{
|
|
programs = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenPrograms(GLsizei n, out GLuint programs)
|
|
{
|
|
programs = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4d(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4d(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLdouble @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4f(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4f(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4d(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4d(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLdouble @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4f(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4f(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, void* @string)
|
|
{
|
|
unsafe { Delegates.glGetProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, object @string)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (void*)@string_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@string_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.ARB_vertex_program pname, void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.ARB_vertex_program pname, void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointerv(Int32 index, GL.Enums.ARB_vertex_program pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointerv(GLuint index, GL.Enums.ARB_vertex_program pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsProgram(Int32 program)
|
|
{
|
|
return Delegates.glIsProgramARB((GLuint)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsProgram(GLuint program)
|
|
{
|
|
return Delegates.glIsProgramARB((GLuint)program);
|
|
}
|
|
|
|
public static
|
|
void BindBuffer(GL.Enums.ARB_vertex_buffer_object target, Int32 buffer)
|
|
{
|
|
Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBuffer(GL.Enums.ARB_vertex_buffer_object target, GLuint buffer)
|
|
{
|
|
Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(GLsizei n, Int32* buffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(GLsizei n, GLuint* buffers)
|
|
{
|
|
unsafe { Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers); }
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(GLsizei n, Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(GLsizei n, GLuint[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(GLsizei n, ref Int32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(GLsizei n, ref GLuint buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(GLsizei n, Int32* buffers)
|
|
{
|
|
buffers = default(Int32*);
|
|
{
|
|
Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(GLsizei n, GLuint* buffers)
|
|
{
|
|
unsafe { Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers); }
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(GLsizei n, Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(GLsizei n, GLuint[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(GLsizei n, out Int32 buffers)
|
|
{
|
|
buffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(GLsizei n, out GLuint buffers)
|
|
{
|
|
buffers = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsBuffer(Int32 buffer)
|
|
{
|
|
return Delegates.glIsBufferARB((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsBuffer(GLuint buffer)
|
|
{
|
|
return Delegates.glIsBufferARB((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferData(GL.Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, void* data, GL.Enums.ARB_vertex_buffer_object usage)
|
|
{
|
|
unsafe { Delegates.glBufferDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLsizeiptrARB)size, (void*)data, (GL.Enums.ARB_vertex_buffer_object)usage); }
|
|
}
|
|
|
|
public static
|
|
void BufferData(GL.Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, object data, GL.Enums.ARB_vertex_buffer_object usage)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glBufferDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject(), (GL.Enums.ARB_vertex_buffer_object)usage);
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, void* data)
|
|
{
|
|
unsafe { Delegates.glBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void BufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, void* data)
|
|
{
|
|
unsafe { Delegates.glGetBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
IntPtr MapBuffer(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object access)
|
|
{
|
|
return Delegates.glMapBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)access);
|
|
}
|
|
|
|
public static
|
|
GLboolean UnmapBuffer(GL.Enums.ARB_vertex_buffer_object target)
|
|
{
|
|
return Delegates.glUnmapBufferARB((GL.Enums.ARB_vertex_buffer_object)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferPointerv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferPointervARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferPointerv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, object @params)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetBufferPointervARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(GLsizei n, Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void GenQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueries(GLsizei n, out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(GLsizei n, out GLuint ids)
|
|
{
|
|
ids = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(GLsizei n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(GLsizei n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(GLsizei n, ref GLuint ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsQuery(Int32 id)
|
|
{
|
|
return Delegates.glIsQueryARB((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsQuery(GLuint id)
|
|
{
|
|
return Delegates.glIsQueryARB((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void BeginQuery(GL.Enums.ARB_occlusion_query target, Int32 id)
|
|
{
|
|
Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginQuery(GL.Enums.ARB_occlusion_query target, GLuint id)
|
|
{
|
|
Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void EndQuery(GL.Enums.ARB_occlusion_query target)
|
|
{
|
|
Delegates.glEndQueryARB((GL.Enums.ARB_occlusion_query)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteObject(Int32 obj)
|
|
{
|
|
Delegates.glDeleteObjectARB((GLhandleARB)obj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteObject(GLhandleARB obj)
|
|
{
|
|
Delegates.glDeleteObjectARB((GLhandleARB)obj);
|
|
}
|
|
|
|
public static
|
|
Int32 GetHandle(GL.Enums.ARB_shader_objects pname)
|
|
{
|
|
return Delegates.glGetHandleARB((GL.Enums.ARB_shader_objects)pname);
|
|
}
|
|
|
|
public static
|
|
void DetachObject(Int32 containerObj, Int32 attachedObj)
|
|
{
|
|
Delegates.glDetachObjectARB((GLhandleARB)containerObj, (GLhandleARB)attachedObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DetachObject(GLhandleARB containerObj, GLhandleARB attachedObj)
|
|
{
|
|
Delegates.glDetachObjectARB((GLhandleARB)containerObj, (GLhandleARB)attachedObj);
|
|
}
|
|
|
|
public static
|
|
Int32 CreateShaderObject(GL.Enums.ARB_shader_objects shaderType)
|
|
{
|
|
return Delegates.glCreateShaderObjectARB((GL.Enums.ARB_shader_objects)shaderType);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, GLint* length)
|
|
{
|
|
{
|
|
Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, GLint* length)
|
|
{
|
|
unsafe { Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length); }
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, GLint[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, GLint[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, ref GLint length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, ref GLint length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CompileShader(Int32 shaderObj)
|
|
{
|
|
Delegates.glCompileShaderARB((GLhandleARB)shaderObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CompileShader(GLhandleARB shaderObj)
|
|
{
|
|
Delegates.glCompileShaderARB((GLhandleARB)shaderObj);
|
|
}
|
|
|
|
public static
|
|
Int32 CreateProgramObject()
|
|
{
|
|
return Delegates.glCreateProgramObjectARB();
|
|
}
|
|
|
|
public static
|
|
void AttachObject(Int32 containerObj, Int32 obj)
|
|
{
|
|
Delegates.glAttachObjectARB((GLhandleARB)containerObj, (GLhandleARB)obj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AttachObject(GLhandleARB containerObj, GLhandleARB obj)
|
|
{
|
|
Delegates.glAttachObjectARB((GLhandleARB)containerObj, (GLhandleARB)obj);
|
|
}
|
|
|
|
public static
|
|
void LinkProgram(Int32 programObj)
|
|
{
|
|
Delegates.glLinkProgramARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LinkProgram(GLhandleARB programObj)
|
|
{
|
|
Delegates.glLinkProgramARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
public static
|
|
void UseProgramObject(Int32 programObj)
|
|
{
|
|
Delegates.glUseProgramObjectARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UseProgramObject(GLhandleARB programObj)
|
|
{
|
|
Delegates.glUseProgramObjectARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
public static
|
|
void ValidateProgram(Int32 programObj)
|
|
{
|
|
Delegates.glValidateProgramARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ValidateProgram(GLhandleARB programObj)
|
|
{
|
|
Delegates.glValidateProgramARB((GLhandleARB)programObj);
|
|
}
|
|
|
|
public static
|
|
void Uniform1f(GLint location, GLfloat v0)
|
|
{
|
|
Delegates.glUniform1fARB((GLint)location, (GLfloat)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2f(GLint location, GLfloat v0, GLfloat v1)
|
|
{
|
|
Delegates.glUniform2fARB((GLint)location, (GLfloat)v0, (GLfloat)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
|
|
{
|
|
Delegates.glUniform3fARB((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
|
|
{
|
|
Delegates.glUniform4fARB((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2, (GLfloat)v3);
|
|
}
|
|
|
|
public static
|
|
void Uniform1i(GLint location, GLint v0)
|
|
{
|
|
Delegates.glUniform1iARB((GLint)location, (GLint)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2i(GLint location, GLint v0, GLint v1)
|
|
{
|
|
Delegates.glUniform2iARB((GLint)location, (GLint)v0, (GLint)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
|
|
{
|
|
Delegates.glUniform3iARB((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
|
|
{
|
|
Delegates.glUniform4iARB((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2, (GLint)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4fv(GLint location, GLsizei count, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4fv(GLint location, GLsizei count, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4fv(GLint location, GLsizei count, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4iv(GLint location, GLsizei count, GLint* value)
|
|
{
|
|
unsafe { Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4iv(GLint location, GLsizei count, GLint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4iv(GLint location, GLsizei count, ref GLint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInfoLog(Int32 obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInfoLog(GLhandleARB obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
public static
|
|
void GetInfoLog(Int32 obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInfoLog(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInfoLog(Int32 obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInfoLog(GLhandleARB obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(GLsizei);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, Int32* obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(Int32*);
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj)
|
|
{
|
|
unsafe { Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, Int32[] obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB[] obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (GLhandleARB* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, out Int32 obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(Int32);
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, out GLhandleARB obj)
|
|
{
|
|
count = default(GLsizei*);
|
|
obj = default(GLhandleARB);
|
|
fixed (GLhandleARB* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, Int32* obj)
|
|
{
|
|
obj = default(Int32*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB* obj)
|
|
{
|
|
obj = default(GLhandleARB*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, Int32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (GLhandleARB* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, out Int32 obj)
|
|
{
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, out GLhandleARB obj)
|
|
{
|
|
obj = default(GLhandleARB);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
fixed (GLhandleARB* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, Int32* obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(Int32*);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, GLhandleARB* obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(GLhandleARB*);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, Int32[] obj)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, GLhandleARB[] obj)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (GLhandleARB* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, out Int32 obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, out GLhandleARB obj)
|
|
{
|
|
count = default(GLsizei);
|
|
obj = default(GLhandleARB);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
fixed (GLhandleARB* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint GetUniformLocation(Int32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocationARB((GLhandleARB)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetUniformLocation(GLhandleARB programObj, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocationARB((GLhandleARB)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformfv(Int32 programObj, GLint location, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformfv(GLhandleARB programObj, GLint location, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetUniformfv(Int32 programObj, GLint location, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformfv(GLhandleARB programObj, GLint location, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformfv(Int32 programObj, GLint location, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformfv(GLhandleARB programObj, GLint location, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformiv(Int32 programObj, GLint location, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformiv(GLhandleARB programObj, GLint location, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetUniformiv(Int32 programObj, GLint location, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformiv(GLhandleARB programObj, GLint location, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformiv(Int32 programObj, GLint location, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformiv(GLhandleARB programObj, GLint location, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(Int32 obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei*);
|
|
source = default(System.Text.StringBuilder[]);
|
|
{
|
|
Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(GLhandleARB obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder[] source)
|
|
{
|
|
unsafe { Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder[])source); }
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(GLhandleARB obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(GLsizei);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindAttribLocation(Int32 programObj, Int32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocationARB((GLhandleARB)programObj, (GLuint)index, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindAttribLocation(GLhandleARB programObj, GLuint index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocationARB((GLhandleARB)programObj, (GLuint)index, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLint);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLint* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint GetAttribLocation(Int32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocationARB((GLhandleARB)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetAttribLocation(GLhandleARB programObj, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocationARB((GLhandleARB)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawBuffers(GLsizei n, GL.Enums.ARB_draw_buffers* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, GL.Enums.ARB_draw_buffers[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, ref GL.Enums.ARB_draw_buffers bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClampColor(GL.Enums.ARB_color_buffer_float target, GL.Enums.ARB_color_buffer_float clamp)
|
|
{
|
|
Delegates.glClampColorARB((GL.Enums.ARB_color_buffer_float)target, (GL.Enums.ARB_color_buffer_float)clamp);
|
|
}
|
|
|
|
}
|
|
|
|
public static class EXT
|
|
{
|
|
public static
|
|
void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
|
|
{
|
|
Delegates.glBlendColorEXT((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
|
|
}
|
|
|
|
public static
|
|
void PolygonOffset(GLfloat factor, GLfloat bias)
|
|
{
|
|
Delegates.glPolygonOffsetEXT((GLfloat)factor, (GLfloat)bias);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
|
|
{
|
|
Delegates.glCopyTexImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLint)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
Delegates.glCopyTexImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GLint)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogram(GL.Enums.HistogramTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
|
|
{
|
|
unsafe { Delegates.glGetHistogramEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmax(GL.Enums.MinmaxTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Histogram(GL.Enums.HistogramTargetEXT target, GLsizei width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glHistogramEXT((GL.Enums.HistogramTargetEXT)target, (GLsizei)width, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink);
|
|
}
|
|
|
|
public static
|
|
void Minmax(GL.Enums.MinmaxTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glMinmaxEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink);
|
|
}
|
|
|
|
public static
|
|
void ResetHistogram(GL.Enums.HistogramTargetEXT target)
|
|
{
|
|
Delegates.glResetHistogramEXT((GL.Enums.HistogramTargetEXT)target);
|
|
}
|
|
|
|
public static
|
|
void ResetMinmax(GL.Enums.MinmaxTargetEXT target)
|
|
{
|
|
Delegates.glResetMinmaxEXT((GL.Enums.MinmaxTargetEXT)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterf(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat @params)
|
|
{
|
|
Delegates.glConvolutionParameterfEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteri(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint @params)
|
|
{
|
|
Delegates.glConvolutionParameteriEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glCopyConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionFilter(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionFilterEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionFilter(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetConvolutionFilterEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, void* span)
|
|
{
|
|
unsafe { Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, object span)
|
|
{
|
|
row = default(void*);
|
|
column = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, void* span)
|
|
{
|
|
row = default(void*);
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, object span)
|
|
{
|
|
row = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, void* span)
|
|
{
|
|
column = default(void*);
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, object span)
|
|
{
|
|
column = default(void*);
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, void* span)
|
|
{
|
|
span = default(void*);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, object span)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
span_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column)
|
|
{
|
|
unsafe { Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
column_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, Int32* textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, GLuint* textures, GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, Int32[] textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, ref Int32 textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, Int32 texture)
|
|
{
|
|
Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, GLuint texture)
|
|
{
|
|
Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(GLsizei n, Int32* textures)
|
|
{
|
|
{
|
|
Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(GLsizei n, GLuint* textures)
|
|
{
|
|
unsafe { Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures); }
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(GLsizei n, Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(GLsizei n, GLuint[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(GLsizei n, ref Int32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(GLsizei n, ref GLuint textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(GLsizei n, Int32* textures)
|
|
{
|
|
textures = default(Int32*);
|
|
{
|
|
Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(GLsizei n, GLuint* textures)
|
|
{
|
|
unsafe { Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures); }
|
|
}
|
|
|
|
public static
|
|
void GenTextures(GLsizei n, Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(GLsizei n, GLuint[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTextures(GLsizei n, out Int32 textures)
|
|
{
|
|
textures = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(GLsizei n, out GLuint textures)
|
|
{
|
|
textures = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsTexture(Int32 texture)
|
|
{
|
|
return Delegates.glIsTextureEXT((GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsTexture(GLuint texture)
|
|
{
|
|
return Delegates.glIsTextureEXT((GLuint)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf* priorities)
|
|
{
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf* priorities)
|
|
{
|
|
unsafe { Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf[] priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf[] priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32* textures, ref GLclampf priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, ref GLclampf priorities)
|
|
{
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf* priorities)
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, Int32[] textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, GLuint[] textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf* priorities)
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref Int32 textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(GLsizei n, ref GLuint textures, ref GLclampf priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* textures_ptr = &textures)
|
|
fixed (GLclampf* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ArrayElement(GLint i)
|
|
{
|
|
Delegates.glArrayElementEXT((GLint)i);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, GLsizei count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count)
|
|
{
|
|
Delegates.glDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointer(GLsizei stride, GLsizei count, GL.Enums.Boolean* pointer)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointerEXT((GLsizei)stride, (GLsizei)count, (GL.Enums.Boolean*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPointerv(GL.Enums.GetPointervPName pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glGetPointervEXT((GL.Enums.GetPointervPName)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPointerv(GL.Enums.GetPointervPName pname, object @params)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetPointervEXT((GL.Enums.GetPointervPName)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, GLsizei count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glIndexPointerEXT((GL.Enums.IndexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glIndexPointerEXT((GL.Enums.IndexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, GLsizei count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glNormalPointerEXT((GL.Enums.NormalPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glNormalPointerEXT((GL.Enums.NormalPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointerEXT((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointerEXT((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, GLsizei count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointerEXT((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointerEXT((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendEquation(GL.Enums.BlendEquationModeEXT mode)
|
|
{
|
|
Delegates.glBlendEquationEXT((GL.Enums.BlendEquationModeEXT)mode);
|
|
}
|
|
|
|
public static
|
|
void PointParameterf(GL.Enums.EXT_point_parameters pname, GLfloat param)
|
|
{
|
|
Delegates.glPointParameterfEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterfv(GL.Enums.EXT_point_parameters pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.EXT_point_parameters pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.EXT_point_parameters pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
|
|
{
|
|
unsafe { Delegates.glColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void ColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelInternalFormat)internalFormat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void ColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelInternalFormat)internalFormat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
|
|
{
|
|
unsafe { Delegates.glGetColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void IndexMaterial(GL.Enums.MaterialFace face, GL.Enums.EXT_index_material mode)
|
|
{
|
|
Delegates.glIndexMaterialEXT((GL.Enums.MaterialFace)face, (GL.Enums.EXT_index_material)mode);
|
|
}
|
|
|
|
public static
|
|
void IndexFunc(GL.Enums.EXT_index_func func, GLclampf @ref)
|
|
{
|
|
Delegates.glIndexFuncEXT((GL.Enums.EXT_index_func)func, (GLclampf)@ref);
|
|
}
|
|
|
|
public static
|
|
void LockArrays(GLint first, GLsizei count)
|
|
{
|
|
Delegates.glLockArraysEXT((GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
public static
|
|
void UnlockArrays()
|
|
{
|
|
Delegates.glUnlockArraysEXT();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CullParameterdv(GL.Enums.EXT_cull_vertex pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CullParameterdv(GL.Enums.EXT_cull_vertex pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CullParameterdv(GL.Enums.EXT_cull_vertex pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CullParameterfv(GL.Enums.EXT_cull_vertex pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CullParameterfv(GL.Enums.EXT_cull_vertex pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CullParameterfv(GL.Enums.EXT_cull_vertex pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.EXT_draw_range_elements type, void* indices)
|
|
{
|
|
{
|
|
Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.EXT_draw_range_elements type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices); }
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.EXT_draw_range_elements type, object indices)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.EXT_draw_range_elements type, object indices)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ApplyTexture(GL.Enums.EXT_light_texture mode)
|
|
{
|
|
Delegates.glApplyTextureEXT((GL.Enums.EXT_light_texture)mode);
|
|
}
|
|
|
|
public static
|
|
void TextureLight(GL.Enums.EXT_light_texture pname)
|
|
{
|
|
Delegates.glTextureLightEXT((GL.Enums.EXT_light_texture)pname);
|
|
}
|
|
|
|
public static
|
|
void TextureMaterial(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
|
|
{
|
|
Delegates.glTextureMaterialEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameteri(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint param)
|
|
{
|
|
Delegates.glPixelTransformParameteriEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterf(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat param)
|
|
{
|
|
Delegates.glPixelTransformParameterfEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3b(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glSecondaryColor3bEXT((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
|
|
{
|
|
Delegates.glSecondaryColor3bEXT((GLbyte)red, (GLbyte)green, (GLbyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3bvEXT((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
|
|
{
|
|
Delegates.glSecondaryColor3dEXT((GLdouble)red, (GLdouble)green, (GLdouble)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3dvEXT((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
|
|
{
|
|
Delegates.glSecondaryColor3fEXT((GLfloat)red, (GLfloat)green, (GLfloat)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3fvEXT((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3i(GLint red, GLint green, GLint blue)
|
|
{
|
|
Delegates.glSecondaryColor3iEXT((GLint)red, (GLint)green, (GLint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3ivEXT((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
|
|
{
|
|
Delegates.glSecondaryColor3sEXT((GLshort)red, (GLshort)green, (GLshort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3svEXT((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
|
|
{
|
|
Delegates.glSecondaryColor3ubEXT((GLubyte)red, (GLubyte)green, (GLubyte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3ubv(GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3ubvEXT((GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ubv(GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3ubvEXT((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ubv(ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3ubvEXT((GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3ui(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3uiEXT((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
|
|
{
|
|
Delegates.glSecondaryColor3uiEXT((GLuint)red, (GLuint)green, (GLuint)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3uiv(Int32* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3uiv(GLuint* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3uivEXT((GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3uiv(Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3uiv(GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3uiv(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3uiv(ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3us(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3usEXT((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
|
|
{
|
|
Delegates.glSecondaryColor3usEXT((GLushort)red, (GLushort)green, (GLushort)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3usv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3usv(GLushort* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3usvEXT((GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3usv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3usv(GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3usv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3usv(ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TextureNormal(GL.Enums.EXT_texture_perturb_normal mode)
|
|
{
|
|
Delegates.glTextureNormalEXT((GL.Enums.EXT_texture_perturb_normal)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
first = default(GLint*);
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
first = default(GLint*);
|
|
count = default(GLsizei);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
count = default(GLsizei*);
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
count = default(GLsizei*);
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
|
|
{
|
|
first = default(GLint);
|
|
count = default(GLsizei);
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
first = *first_ptr;
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordf(GLfloat coord)
|
|
{
|
|
Delegates.glFogCoordfEXT((GLfloat)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordfv(GLfloat* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoordfvEXT((GLfloat*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordfv(GLfloat[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoordfvEXT((GLfloat*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordfv(ref GLfloat coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoordfvEXT((GLfloat*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordd(GLdouble coord)
|
|
{
|
|
Delegates.glFogCoorddEXT((GLdouble)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoorddv(GLdouble* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoorddvEXT((GLdouble*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoorddv(GLdouble[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoorddvEXT((GLdouble*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoorddv(ref GLdouble coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoorddvEXT((GLdouble*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointer(GL.Enums.EXT_fog_coord type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointerEXT((GL.Enums.EXT_fog_coord)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointer(GL.Enums.EXT_fog_coord type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glFogCoordPointerEXT((GL.Enums.EXT_fog_coord)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3b(Byte tx, Byte ty, Byte tz)
|
|
{
|
|
Delegates.glTangent3bEXT((GLbyte)tx, (GLbyte)ty, (GLbyte)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3b(GLbyte tx, GLbyte ty, GLbyte tz)
|
|
{
|
|
Delegates.glTangent3bEXT((GLbyte)tx, (GLbyte)ty, (GLbyte)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glTangent3bvEXT((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glTangent3bvEXT((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3d(GLdouble tx, GLdouble ty, GLdouble tz)
|
|
{
|
|
Delegates.glTangent3dEXT((GLdouble)tx, (GLdouble)ty, (GLdouble)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glTangent3dvEXT((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3f(GLfloat tx, GLfloat ty, GLfloat tz)
|
|
{
|
|
Delegates.glTangent3fEXT((GLfloat)tx, (GLfloat)ty, (GLfloat)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTangent3fvEXT((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3i(GLint tx, GLint ty, GLint tz)
|
|
{
|
|
Delegates.glTangent3iEXT((GLint)tx, (GLint)ty, (GLint)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glTangent3ivEXT((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3s(GLshort tx, GLshort ty, GLshort tz)
|
|
{
|
|
Delegates.glTangent3sEXT((GLshort)tx, (GLshort)ty, (GLshort)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glTangent3svEXT((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3b(Byte bx, Byte by, Byte bz)
|
|
{
|
|
Delegates.glBinormal3bEXT((GLbyte)bx, (GLbyte)by, (GLbyte)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3b(GLbyte bx, GLbyte by, GLbyte bz)
|
|
{
|
|
Delegates.glBinormal3bEXT((GLbyte)bx, (GLbyte)by, (GLbyte)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3bv(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glBinormal3bvEXT((GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3bv(GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3bvEXT((GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3bv(Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3bv(GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3bv(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3bv(ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3d(GLdouble bx, GLdouble by, GLdouble bz)
|
|
{
|
|
Delegates.glBinormal3dEXT((GLdouble)bx, (GLdouble)by, (GLdouble)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3dvEXT((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3dvEXT((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3f(GLfloat bx, GLfloat by, GLfloat bz)
|
|
{
|
|
Delegates.glBinormal3fEXT((GLfloat)bx, (GLfloat)by, (GLfloat)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3fvEXT((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3fvEXT((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3i(GLint bx, GLint by, GLint bz)
|
|
{
|
|
Delegates.glBinormal3iEXT((GLint)bx, (GLint)by, (GLint)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3ivEXT((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3ivEXT((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3s(GLshort bx, GLshort by, GLshort bz)
|
|
{
|
|
Delegates.glBinormal3sEXT((GLshort)bx, (GLshort)by, (GLshort)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3svEXT((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3svEXT((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TangentPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTangentPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TangentPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTangentPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BinormalPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glBinormalPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void BinormalPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glBinormalPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendFuncSeparate(GL.Enums.EXT_blend_func_separate sfactorRGB, GL.Enums.EXT_blend_func_separate dfactorRGB, GL.Enums.EXT_blend_func_separate sfactorAlpha, GL.Enums.EXT_blend_func_separate dfactorAlpha)
|
|
{
|
|
Delegates.glBlendFuncSeparateEXT((GL.Enums.EXT_blend_func_separate)sfactorRGB, (GL.Enums.EXT_blend_func_separate)dfactorRGB, (GL.Enums.EXT_blend_func_separate)sfactorAlpha, (GL.Enums.EXT_blend_func_separate)dfactorAlpha);
|
|
}
|
|
|
|
public static
|
|
void VertexWeightf(GLfloat weight)
|
|
{
|
|
Delegates.glVertexWeightfEXT((GLfloat)weight);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeightfv(GLfloat* weight)
|
|
{
|
|
unsafe { Delegates.glVertexWeightfvEXT((GLfloat*)weight); }
|
|
}
|
|
|
|
public static
|
|
void VertexWeightfv(GLfloat[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeightfvEXT((GLfloat*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeightfv(ref GLfloat weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeightfvEXT((GLfloat*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeightPointer(GLsizei size, GL.Enums.EXT_vertex_weighting type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexWeightPointerEXT((GLsizei)size, (GL.Enums.EXT_vertex_weighting)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexWeightPointer(GLsizei size, GL.Enums.EXT_vertex_weighting type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexWeightPointerEXT((GLsizei)size, (GL.Enums.EXT_vertex_weighting)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleMask(GLclampf value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleMaskEXT((GLclampf)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
public static
|
|
void SamplePattern(GL.Enums.EXT_multisample pattern)
|
|
{
|
|
Delegates.glSamplePatternEXT((GL.Enums.EXT_multisample)pattern);
|
|
}
|
|
|
|
public static
|
|
void BeginVertexShader()
|
|
{
|
|
Delegates.glBeginVertexShaderEXT();
|
|
}
|
|
|
|
public static
|
|
void EndVertexShader()
|
|
{
|
|
Delegates.glEndVertexShaderEXT();
|
|
}
|
|
|
|
public static
|
|
void BindVertexShader(Int32 id)
|
|
{
|
|
Delegates.glBindVertexShaderEXT((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindVertexShader(GLuint id)
|
|
{
|
|
Delegates.glBindVertexShaderEXT((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
Int32 GenVertexShaders(Int32 range)
|
|
{
|
|
return Delegates.glGenVertexShadersEXT((GLuint)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenVertexShaders(GLuint range)
|
|
{
|
|
return Delegates.glGenVertexShadersEXT((GLuint)range);
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexShader(Int32 id)
|
|
{
|
|
Delegates.glDeleteVertexShaderEXT((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexShader(GLuint id)
|
|
{
|
|
Delegates.glDeleteVertexShaderEXT((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp1(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1)
|
|
{
|
|
Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp1(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1)
|
|
{
|
|
Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp2(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2)
|
|
{
|
|
Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp2(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2)
|
|
{
|
|
Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp3(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2, Int32 arg3)
|
|
{
|
|
Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2, (GLuint)arg3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp3(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)
|
|
{
|
|
Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2, (GLuint)arg3);
|
|
}
|
|
|
|
public static
|
|
void Swizzle(Int32 res, Int32 @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
|
|
{
|
|
Delegates.glSwizzleEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Swizzle(GLuint res, GLuint @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
|
|
{
|
|
Delegates.glSwizzleEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
|
|
}
|
|
|
|
public static
|
|
void WriteMask(Int32 res, Int32 @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
|
|
{
|
|
Delegates.glWriteMaskEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void WriteMask(GLuint res, GLuint @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
|
|
{
|
|
Delegates.glWriteMaskEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
|
|
}
|
|
|
|
public static
|
|
void InsertComponent(Int32 res, Int32 src, Int32 num)
|
|
{
|
|
Delegates.glInsertComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void InsertComponent(GLuint res, GLuint src, GLuint num)
|
|
{
|
|
Delegates.glInsertComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
|
|
}
|
|
|
|
public static
|
|
void ExtractComponent(Int32 res, Int32 src, Int32 num)
|
|
{
|
|
Delegates.glExtractComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExtractComponent(GLuint res, GLuint src, GLuint num)
|
|
{
|
|
Delegates.glExtractComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
|
|
}
|
|
|
|
public static
|
|
Int32 GenSymbols(GL.Enums.EXT_vertex_shader datatype, GL.Enums.EXT_vertex_shader storagetype, GL.Enums.EXT_vertex_shader range, Int32 components)
|
|
{
|
|
return Delegates.glGenSymbolsEXT((GL.Enums.EXT_vertex_shader)datatype, (GL.Enums.EXT_vertex_shader)storagetype, (GL.Enums.EXT_vertex_shader)range, (GLuint)components);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenSymbols(GL.Enums.EXT_vertex_shader datatype, GL.Enums.EXT_vertex_shader storagetype, GL.Enums.EXT_vertex_shader range, GLuint components)
|
|
{
|
|
return Delegates.glGenSymbolsEXT((GL.Enums.EXT_vertex_shader)datatype, (GL.Enums.EXT_vertex_shader)storagetype, (GL.Enums.EXT_vertex_shader)range, (GLuint)components);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetInvariant(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
{
|
|
Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetInvariant(GLuint id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
unsafe { Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
|
|
}
|
|
|
|
public static
|
|
void SetInvariant(Int32 id, GL.Enums.EXT_vertex_shader type, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetInvariant(GLuint id, GL.Enums.EXT_vertex_shader type, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetLocalConstant(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
{
|
|
Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetLocalConstant(GLuint id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
unsafe { Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
|
|
}
|
|
|
|
public static
|
|
void SetLocalConstant(Int32 id, GL.Enums.EXT_vertex_shader type, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetLocalConstant(GLuint id, GL.Enums.EXT_vertex_shader type, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantbv(Int32 id, Byte* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantbv(GLuint id, GLbyte* addr)
|
|
{
|
|
unsafe { Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantbv(Int32 id, Byte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantbv(GLuint id, GLbyte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantbv(Int32 id, ref Byte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantbv(GLuint id, ref GLbyte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantsv(Int32 id, GLshort* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantsv(GLuint id, GLshort* addr)
|
|
{
|
|
unsafe { Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantsv(Int32 id, GLshort[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantsv(GLuint id, GLshort[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantsv(Int32 id, ref GLshort addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantsv(GLuint id, ref GLshort addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantiv(Int32 id, GLint* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantivEXT((GLuint)id, (GLint*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantiv(GLuint id, GLint* addr)
|
|
{
|
|
unsafe { Delegates.glVariantivEXT((GLuint)id, (GLint*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantiv(Int32 id, GLint[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantiv(GLuint id, GLint[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantiv(Int32 id, ref GLint addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantiv(GLuint id, ref GLint addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantfv(Int32 id, GLfloat* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantfv(GLuint id, GLfloat* addr)
|
|
{
|
|
unsafe { Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantfv(Int32 id, GLfloat[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantfv(GLuint id, GLfloat[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantfv(Int32 id, ref GLfloat addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantfv(GLuint id, ref GLfloat addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantdv(Int32 id, GLdouble* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantdv(GLuint id, GLdouble* addr)
|
|
{
|
|
unsafe { Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantdv(Int32 id, GLdouble[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantdv(GLuint id, GLdouble[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantdv(Int32 id, ref GLdouble addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantdv(GLuint id, ref GLdouble addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantubv(Int32 id, GLubyte* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantubv(GLuint id, GLubyte* addr)
|
|
{
|
|
unsafe { Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantubv(Int32 id, GLubyte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantubv(GLuint id, GLubyte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantubv(Int32 id, ref GLubyte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantubv(GLuint id, ref GLubyte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantusv(Int32 id, Int16* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantusv(GLuint id, GLushort* addr)
|
|
{
|
|
unsafe { Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantusv(Int32 id, Int16[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantusv(GLuint id, GLushort[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantusv(Int32 id, ref Int16 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantusv(GLuint id, ref GLushort addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantuiv(Int32 id, Int32* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantuiv(GLuint id, GLuint* addr)
|
|
{
|
|
unsafe { Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr); }
|
|
}
|
|
|
|
public static
|
|
void Variantuiv(Int32 id, Int32[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantuiv(GLuint id, GLuint[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantuiv(Int32 id, ref Int32 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantuiv(GLuint id, ref GLuint addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VariantPointer(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, void* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VariantPointer(GLuint id, GL.Enums.EXT_vertex_shader type, GLuint stride, void* addr)
|
|
{
|
|
unsafe { Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr); }
|
|
}
|
|
|
|
public static
|
|
void VariantPointer(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VariantPointer(GLuint id, GL.Enums.EXT_vertex_shader type, GLuint stride, object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EnableVariantClientState(Int32 id)
|
|
{
|
|
Delegates.glEnableVariantClientStateEXT((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVariantClientState(GLuint id)
|
|
{
|
|
Delegates.glEnableVariantClientStateEXT((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void DisableVariantClientState(Int32 id)
|
|
{
|
|
Delegates.glDisableVariantClientStateEXT((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVariantClientState(GLuint id)
|
|
{
|
|
Delegates.glDisableVariantClientStateEXT((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
Int32 BindLightParameter(GL.Enums.LightName light, GL.Enums.LightParameter value)
|
|
{
|
|
return Delegates.glBindLightParameterEXT((GL.Enums.LightName)light, (GL.Enums.LightParameter)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindMaterialParameter(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter value)
|
|
{
|
|
return Delegates.glBindMaterialParameterEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindTexGenParameter(GL.Enums.EXT_vertex_shader unit, GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter value)
|
|
{
|
|
return Delegates.glBindTexGenParameterEXT((GL.Enums.EXT_vertex_shader)unit, (GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindTextureUnitParameter(GL.Enums.EXT_vertex_shader unit, GL.Enums.EXT_vertex_shader value)
|
|
{
|
|
return Delegates.glBindTextureUnitParameterEXT((GL.Enums.EXT_vertex_shader)unit, (GL.Enums.EXT_vertex_shader)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindParameter(GL.Enums.EXT_vertex_shader value)
|
|
{
|
|
return Delegates.glBindParameterEXT((GL.Enums.EXT_vertex_shader)value);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsVariantEnabled(Int32 id, GL.Enums.EXT_vertex_shader cap)
|
|
{
|
|
return Delegates.glIsVariantEnabledEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)cap);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsVariantEnabled(GLuint id, GL.Enums.EXT_vertex_shader cap)
|
|
{
|
|
return Delegates.glIsVariantEnabledEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)cap);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetVariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
data = default(GLint*);
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
data = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantPointerv(Int32 id, GL.Enums.EXT_vertex_shader value, void* data)
|
|
{
|
|
data = default(void*);
|
|
{
|
|
Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantPointerv(GLuint id, GL.Enums.EXT_vertex_shader value, void* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetVariantPointerv(Int32 id, GL.Enums.EXT_vertex_shader value, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantPointerv(GLuint id, GL.Enums.EXT_vertex_shader value, object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetInvariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
data = default(GLint*);
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
data = default(GLfloat*);
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetLocalConstantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
data = default(GLint*);
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
data = default(GLfloat*);
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
|
|
{
|
|
data = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ActiveStencilFace(GL.Enums.EXT_stencil_two_side face)
|
|
{
|
|
Delegates.glActiveStencilFaceEXT((GL.Enums.EXT_stencil_two_side)face);
|
|
}
|
|
|
|
public static
|
|
void DepthBounds(GLclampd zmin, GLclampd zmax)
|
|
{
|
|
Delegates.glDepthBoundsEXT((GLclampd)zmin, (GLclampd)zmax);
|
|
}
|
|
|
|
public static
|
|
void BlendEquationSeparate(GL.Enums.BlendEquationModeEXT modeRGB, GL.Enums.BlendEquationModeEXT modeAlpha)
|
|
{
|
|
Delegates.glBlendEquationSeparateEXT((GL.Enums.BlendEquationModeEXT)modeRGB, (GL.Enums.BlendEquationModeEXT)modeAlpha);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsRenderbuffer(Int32 renderbuffer)
|
|
{
|
|
return Delegates.glIsRenderbufferEXT((GLuint)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsRenderbuffer(GLuint renderbuffer)
|
|
{
|
|
return Delegates.glIsRenderbufferEXT((GLuint)renderbuffer);
|
|
}
|
|
|
|
public static
|
|
void BindRenderbuffer(GL.Enums.EXT_framebuffer_object target, Int32 renderbuffer)
|
|
{
|
|
Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindRenderbuffer(GL.Enums.EXT_framebuffer_object target, GLuint renderbuffer)
|
|
{
|
|
Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteRenderbuffers(GLsizei n, Int32* renderbuffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteRenderbuffers(GLsizei n, GLuint* renderbuffers)
|
|
{
|
|
unsafe { Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers); }
|
|
}
|
|
|
|
public static
|
|
void DeleteRenderbuffers(GLsizei n, Int32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteRenderbuffers(GLsizei n, GLuint[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteRenderbuffers(GLsizei n, ref Int32 renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteRenderbuffers(GLsizei n, ref GLuint renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenRenderbuffers(GLsizei n, Int32* renderbuffers)
|
|
{
|
|
renderbuffers = default(Int32*);
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
|
|
{
|
|
unsafe { Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers); }
|
|
}
|
|
|
|
public static
|
|
void GenRenderbuffers(GLsizei n, Int32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenRenderbuffers(GLsizei n, GLuint[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenRenderbuffers(GLsizei n, out Int32 renderbuffers)
|
|
{
|
|
renderbuffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
renderbuffers = *renderbuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenRenderbuffers(GLsizei n, out GLuint renderbuffers)
|
|
{
|
|
renderbuffers = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
|
|
renderbuffers = *renderbuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorage(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glRenderbufferStorageEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)internalformat, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsFramebuffer(Int32 framebuffer)
|
|
{
|
|
return Delegates.glIsFramebufferEXT((GLuint)framebuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsFramebuffer(GLuint framebuffer)
|
|
{
|
|
return Delegates.glIsFramebufferEXT((GLuint)framebuffer);
|
|
}
|
|
|
|
public static
|
|
void BindFramebuffer(GL.Enums.EXT_framebuffer_object target, Int32 framebuffer)
|
|
{
|
|
Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)framebuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFramebuffer(GL.Enums.EXT_framebuffer_object target, GLuint framebuffer)
|
|
{
|
|
Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)framebuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFramebuffers(GLsizei n, Int32* framebuffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFramebuffers(GLsizei n, GLuint* framebuffers)
|
|
{
|
|
unsafe { Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers); }
|
|
}
|
|
|
|
public static
|
|
void DeleteFramebuffers(GLsizei n, Int32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFramebuffers(GLsizei n, GLuint[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFramebuffers(GLsizei n, ref Int32 framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFramebuffers(GLsizei n, ref GLuint framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFramebuffers(GLsizei n, Int32* framebuffers)
|
|
{
|
|
framebuffers = default(Int32*);
|
|
{
|
|
Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFramebuffers(GLsizei n, GLuint* framebuffers)
|
|
{
|
|
unsafe { Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers); }
|
|
}
|
|
|
|
public static
|
|
void GenFramebuffers(GLsizei n, Int32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFramebuffers(GLsizei n, GLuint[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFramebuffers(GLsizei n, out Int32 framebuffers)
|
|
{
|
|
framebuffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
framebuffers = *framebuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFramebuffers(GLsizei n, out GLuint framebuffers)
|
|
{
|
|
framebuffers = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
|
|
framebuffers = *framebuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GL.Enums.GLenum CheckFramebufferStatus(GL.Enums.EXT_framebuffer_object target)
|
|
{
|
|
return Delegates.glCheckFramebufferStatusEXT((GL.Enums.EXT_framebuffer_object)target);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture1D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture1D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture2D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture2D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture3D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level, GLint zoffset)
|
|
{
|
|
Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level, (GLint)zoffset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture3D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level, GLint zoffset)
|
|
{
|
|
Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level, (GLint)zoffset);
|
|
}
|
|
|
|
public static
|
|
void FramebufferRenderbuffer(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object renderbuffertarget, Int32 renderbuffer)
|
|
{
|
|
Delegates.glFramebufferRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)renderbuffertarget, (GLuint)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferRenderbuffer(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer)
|
|
{
|
|
Delegates.glFramebufferRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)renderbuffertarget, (GLuint)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenerateMipmap(GL.Enums.EXT_framebuffer_object target)
|
|
{
|
|
Delegates.glGenerateMipmapEXT((GL.Enums.EXT_framebuffer_object)target);
|
|
}
|
|
|
|
public static
|
|
void StencilClearTag(GLsizei stencilTagBits, Int32 stencilClearTag)
|
|
{
|
|
Delegates.glStencilClearTagEXT((GLsizei)stencilTagBits, (GLuint)stencilClearTag);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilClearTag(GLsizei stencilTagBits, GLuint stencilClearTag)
|
|
{
|
|
Delegates.glStencilClearTagEXT((GLsizei)stencilTagBits, (GLuint)stencilClearTag);
|
|
}
|
|
|
|
public static
|
|
void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GL.Enums.ClearBufferMask mask, GL.Enums.EXT_framebuffer_blit filter)
|
|
{
|
|
Delegates.glBlitFramebufferEXT((GLint)srcX0, (GLint)srcY0, (GLint)srcX1, (GLint)srcY1, (GLint)dstX0, (GLint)dstY0, (GLint)dstX1, (GLint)dstY1, (GL.Enums.ClearBufferMask)mask, (GL.Enums.EXT_framebuffer_blit)filter);
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorageMultisample(GL.Enums.EXT_framebuffer_multisample target, GLsizei samples, GL.Enums.EXT_framebuffer_multisample internalformat, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glRenderbufferStorageMultisampleEXT((GL.Enums.EXT_framebuffer_multisample)target, (GLsizei)samples, (GL.Enums.EXT_framebuffer_multisample)internalformat, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, GLint64EXT* @params)
|
|
{
|
|
@params = default(GLint64EXT*);
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, GLint64EXT* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, GLint64EXT[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint64EXT* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, GLint64EXT[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint64EXT* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, out GLint64EXT @params)
|
|
{
|
|
@params = default(GLint64EXT);
|
|
unsafe
|
|
{
|
|
fixed (GLint64EXT* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, out GLint64EXT @params)
|
|
{
|
|
@params = default(GLint64EXT);
|
|
unsafe
|
|
{
|
|
fixed (GLint64EXT* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, Int64* @params)
|
|
{
|
|
@params = default(Int64*);
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, GLuint64EXT* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, Int64[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, GLuint64EXT[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint64EXT* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, out Int64 @params)
|
|
{
|
|
@params = default(Int64);
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, out GLuint64EXT @params)
|
|
{
|
|
@params = default(GLuint64EXT);
|
|
unsafe
|
|
{
|
|
fixed (GLuint64EXT* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level)
|
|
{
|
|
Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTextureLayer(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level, GLint layer)
|
|
{
|
|
Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GLint)layer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTextureLayer(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GLint layer)
|
|
{
|
|
Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GLint)layer);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTextureFace(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level, GL.Enums.TextureTarget face)
|
|
{
|
|
Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GL.Enums.TextureTarget)face);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTextureFace(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GL.Enums.TextureTarget face)
|
|
{
|
|
Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GL.Enums.TextureTarget)face);
|
|
}
|
|
|
|
public static
|
|
void ProgramParameteri(Int32 program, GL.Enums.EXT_geometry_shader4 pname, GLint value)
|
|
{
|
|
Delegates.glProgramParameteriEXT((GLuint)program, (GL.Enums.EXT_geometry_shader4)pname, (GLint)value);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameteri(GLuint program, GL.Enums.EXT_geometry_shader4 pname, GLint value)
|
|
{
|
|
Delegates.glProgramParameteriEXT((GLuint)program, (GL.Enums.EXT_geometry_shader4)pname, (GLint)value);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1i(Int32 index, GLint x)
|
|
{
|
|
Delegates.glVertexAttribI1iEXT((GLuint)index, (GLint)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1i(GLuint index, GLint x)
|
|
{
|
|
Delegates.glVertexAttribI1iEXT((GLuint)index, (GLint)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2i(Int32 index, GLint x, GLint y)
|
|
{
|
|
Delegates.glVertexAttribI2iEXT((GLuint)index, (GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2i(GLuint index, GLint x, GLint y)
|
|
{
|
|
Delegates.glVertexAttribI2iEXT((GLuint)index, (GLint)x, (GLint)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3i(Int32 index, GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glVertexAttribI3iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glVertexAttribI3iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4i(Int32 index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glVertexAttribI4iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glVertexAttribI4iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1ui(Int32 index, Int32 x)
|
|
{
|
|
Delegates.glVertexAttribI1uiEXT((GLuint)index, (GLuint)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1ui(GLuint index, GLuint x)
|
|
{
|
|
Delegates.glVertexAttribI1uiEXT((GLuint)index, (GLuint)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2ui(Int32 index, Int32 x, Int32 y)
|
|
{
|
|
Delegates.glVertexAttribI2uiEXT((GLuint)index, (GLuint)x, (GLuint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
|
|
{
|
|
Delegates.glVertexAttribI2uiEXT((GLuint)index, (GLuint)x, (GLuint)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3ui(Int32 index, Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glVertexAttribI3uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
|
|
{
|
|
Delegates.glVertexAttribI3uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4ui(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glVertexAttribI4uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
|
|
{
|
|
Delegates.glVertexAttribI4uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4iv(Int32 index, GLint* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4iv(GLuint index, GLint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4iv(Int32 index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4iv(GLuint index, GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4iv(Int32 index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4iv(GLuint index, ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4uiv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4uiv(GLuint index, GLuint* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4uiv(Int32 index, Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4uiv(GLuint index, GLuint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4uiv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4uiv(GLuint index, ref GLuint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4bv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4bv(GLuint index, GLbyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4bv(Int32 index, Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4bv(GLuint index, GLbyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4bv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4bv(GLuint index, ref GLbyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4ubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4ubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4ubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4ubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4ubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4ubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4usv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4usv(GLuint index, GLushort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4usv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4usv(GLuint index, GLushort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4usv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4usv(GLuint index, ref GLushort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribIPointer(Int32 index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribIPointer(GLuint index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribIPointer(Int32 index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribIPointer(GLuint index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformuiv(Int32 program, GLint location, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformuiv(GLuint program, GLint location, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetUniformuiv(Int32 program, GLint location, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformuiv(GLuint program, GLint location, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformuiv(Int32 program, GLint location, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformuiv(GLuint program, GLint location, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindFragDataLocation(Int32 program, Int32 color, System.String name)
|
|
{
|
|
Delegates.glBindFragDataLocationEXT((GLuint)program, (GLuint)color, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFragDataLocation(GLuint program, GLuint color, System.String name)
|
|
{
|
|
Delegates.glBindFragDataLocationEXT((GLuint)program, (GLuint)color, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
GLint GetFragDataLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetFragDataLocationEXT((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetFragDataLocation(GLuint program, System.String name)
|
|
{
|
|
return Delegates.glGetFragDataLocationEXT((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void Uniform1ui(GLint location, Int32 v0)
|
|
{
|
|
Delegates.glUniform1uiEXT((GLint)location, (GLuint)v0);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1ui(GLint location, GLuint v0)
|
|
{
|
|
Delegates.glUniform1uiEXT((GLint)location, (GLuint)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2ui(GLint location, Int32 v0, Int32 v1)
|
|
{
|
|
Delegates.glUniform2uiEXT((GLint)location, (GLuint)v0, (GLuint)v1);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2ui(GLint location, GLuint v0, GLuint v1)
|
|
{
|
|
Delegates.glUniform2uiEXT((GLint)location, (GLuint)v0, (GLuint)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3ui(GLint location, Int32 v0, Int32 v1, Int32 v2)
|
|
{
|
|
Delegates.glUniform3uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
|
|
{
|
|
Delegates.glUniform3uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4ui(GLint location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
|
|
{
|
|
Delegates.glUniform4uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2, (GLuint)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
|
|
{
|
|
Delegates.glUniform4uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2, (GLuint)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1uiv(GLint location, GLsizei count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1uiv(GLint location, GLsizei count, GLuint* value)
|
|
{
|
|
unsafe { Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1uiv(GLint location, GLsizei count, Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1uiv(GLint location, GLsizei count, GLuint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1uiv(GLint location, GLsizei count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1uiv(GLint location, GLsizei count, ref GLuint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2uiv(GLint location, GLsizei count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2uiv(GLint location, GLsizei count, GLuint* value)
|
|
{
|
|
unsafe { Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2uiv(GLint location, GLsizei count, Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2uiv(GLint location, GLsizei count, GLuint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2uiv(GLint location, GLsizei count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2uiv(GLint location, GLsizei count, ref GLuint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3uiv(GLint location, GLsizei count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3uiv(GLint location, GLsizei count, GLuint* value)
|
|
{
|
|
unsafe { Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3uiv(GLint location, GLsizei count, Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3uiv(GLint location, GLsizei count, GLuint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3uiv(GLint location, GLsizei count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3uiv(GLint location, GLsizei count, ref GLuint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4uiv(GLint location, GLsizei count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4uiv(GLint location, GLsizei count, GLuint* value)
|
|
{
|
|
unsafe { Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4uiv(GLint location, GLsizei count, Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4uiv(GLint location, GLsizei count, GLuint[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4uiv(GLint location, GLsizei count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4uiv(GLint location, GLsizei count, ref GLuint value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawArraysInstanced(GL.Enums.BeginMode mode, GLint start, GLsizei count, GLsizei primcount)
|
|
{
|
|
Delegates.glDrawArraysInstancedEXT((GL.Enums.BeginMode)mode, (GLint)start, (GLsizei)count, (GLsizei)primcount);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawElementsInstanced(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.EXT_draw_instanced type, void* indices, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glDrawElementsInstancedEXT((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices, (GLsizei)primcount); }
|
|
}
|
|
|
|
public static
|
|
void DrawElementsInstanced(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.EXT_draw_instanced type, object indices, GLsizei primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawElementsInstancedEXT((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexBuffer(GL.Enums.TextureTarget target, GL.Enums.EXT_texture_buffer_object internalformat, Int32 buffer)
|
|
{
|
|
Delegates.glTexBufferEXT((GL.Enums.TextureTarget)target, (GL.Enums.EXT_texture_buffer_object)internalformat, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexBuffer(GL.Enums.TextureTarget target, GL.Enums.EXT_texture_buffer_object internalformat, GLuint buffer)
|
|
{
|
|
Delegates.glTexBufferEXT((GL.Enums.TextureTarget)target, (GL.Enums.EXT_texture_buffer_object)internalformat, (GLuint)buffer);
|
|
}
|
|
|
|
public static
|
|
void ColorMaskIndexed(Int32 index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glColorMaskIndexedEXT((GLuint)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorMaskIndexed(GLuint index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
|
|
{
|
|
Delegates.glColorMaskIndexedEXT((GLuint)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBooleanIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBooleanIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GLint* data)
|
|
{
|
|
data = default(GLint*);
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GLint* data)
|
|
{
|
|
unsafe { Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GLint[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, out GLint data)
|
|
{
|
|
data = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* data_ptr = &data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EnableIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
|
|
{
|
|
Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
public static
|
|
void DisableIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
|
|
{
|
|
Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsEnabledIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsEnabledIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
|
|
{
|
|
return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
|
|
}
|
|
|
|
public static
|
|
void UniformBuffer(Int32 program, GLint location, Int32 buffer)
|
|
{
|
|
Delegates.glUniformBufferEXT((GLuint)program, (GLint)location, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UniformBuffer(GLuint program, GLint location, GLuint buffer)
|
|
{
|
|
Delegates.glUniformBufferEXT((GLuint)program, (GLint)location, (GLuint)buffer);
|
|
}
|
|
|
|
public static
|
|
GLint GetUniformBufferSize(Int32 program, GLint location)
|
|
{
|
|
return Delegates.glGetUniformBufferSizeEXT((GLuint)program, (GLint)location);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetUniformBufferSize(GLuint program, GLint location)
|
|
{
|
|
return Delegates.glGetUniformBufferSizeEXT((GLuint)program, (GLint)location);
|
|
}
|
|
|
|
public static
|
|
GLintptr GetUniformOffset(Int32 program, GLint location)
|
|
{
|
|
return Delegates.glGetUniformOffsetEXT((GLuint)program, (GLint)location);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLintptr GetUniformOffset(GLuint program, GLint location)
|
|
{
|
|
return Delegates.glGetUniformOffsetEXT((GLuint)program, (GLint)location);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)
|
|
{
|
|
Delegates.glClearColorIiEXT((GLint)red, (GLint)green, (GLint)blue, (GLint)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearColorIui(Int32 red, Int32 green, Int32 blue, Int32 alpha)
|
|
{
|
|
Delegates.glClearColorIuiEXT((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
|
|
{
|
|
Delegates.glClearColorIuiEXT((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
|
|
}
|
|
|
|
}
|
|
|
|
public static class SGIS
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLfloat* weights)
|
|
{
|
|
unsafe { Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights); }
|
|
}
|
|
|
|
public static
|
|
void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLfloat[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = weights)
|
|
{
|
|
Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, out GLfloat weights)
|
|
{
|
|
weights = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = &weights)
|
|
{
|
|
Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights_ptr);
|
|
weights = *weights_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, GLfloat* weights)
|
|
{
|
|
unsafe { Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights); }
|
|
}
|
|
|
|
public static
|
|
void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, GLfloat[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = weights)
|
|
{
|
|
Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, ref GLfloat weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* weights_ptr = &weights)
|
|
{
|
|
Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameteri(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint param)
|
|
{
|
|
Delegates.glPixelTexGenParameteriSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterf(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat param)
|
|
{
|
|
Delegates.glPixelTexGenParameterfSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage4D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage4D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage4D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)woffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage4D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexSubImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)woffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetDetailTexFunc(GL.Enums.TextureTarget target, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetDetailTexFunc(GL.Enums.TextureTarget target, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetDetailTexFunc(GL.Enums.TextureTarget target, out GLfloat points)
|
|
{
|
|
points = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSharpenTexFunc(GL.Enums.TextureTarget target, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetSharpenTexFunc(GL.Enums.TextureTarget target, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetSharpenTexFunc(GL.Enums.TextureTarget target, out GLfloat points)
|
|
{
|
|
points = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleMask(GLclampf value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleMaskSGIS((GLclampf)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
public static
|
|
void SamplePattern(GL.Enums.SamplePatternSGIS pattern)
|
|
{
|
|
Delegates.glSamplePatternSGIS((GL.Enums.SamplePatternSGIS)pattern);
|
|
}
|
|
|
|
public static
|
|
void PointParameterf(GL.Enums.SGIS_point_parameters pname, GLfloat param)
|
|
{
|
|
Delegates.glPointParameterfSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterfv(GL.Enums.SGIS_point_parameters pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.SGIS_point_parameters pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterfv(GL.Enums.SGIS_point_parameters pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogFunc(GLsizei n, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void FogFunc(GLsizei n, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogFunc(GLsizei n, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFogFunc(GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glGetFogFuncSGIS((GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetFogFunc(GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glGetFogFuncSGIS((GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFogFunc(out GLfloat points)
|
|
{
|
|
points = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glGetFogFuncSGIS((GLfloat*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TextureColorMask(GL.Enums.Boolean red, GL.Enums.Boolean green, GL.Enums.Boolean blue, GL.Enums.Boolean alpha)
|
|
{
|
|
Delegates.glTextureColorMaskSGIS((GL.Enums.Boolean)red, (GL.Enums.Boolean)green, (GL.Enums.Boolean)blue, (GL.Enums.Boolean)alpha);
|
|
}
|
|
|
|
}
|
|
|
|
public static class SGI
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void ColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
|
|
{
|
|
Delegates.glCopyColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glGetColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class SGIX
|
|
{
|
|
public static
|
|
void PixelTexGen(GL.Enums.SGIX_pixel_texture mode)
|
|
{
|
|
Delegates.glPixelTexGenSGIX((GL.Enums.SGIX_pixel_texture)mode);
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterf(GL.Enums.SGIX_sprite pname, GLfloat param)
|
|
{
|
|
Delegates.glSpriteParameterfSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SpriteParameterfv(GL.Enums.SGIX_sprite pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterfv(GL.Enums.SGIX_sprite pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterfv(GL.Enums.SGIX_sprite pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameteri(GL.Enums.SGIX_sprite pname, GLint param)
|
|
{
|
|
Delegates.glSpriteParameteriSGIX((GL.Enums.SGIX_sprite)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SpriteParameteriv(GL.Enums.SGIX_sprite pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void SpriteParameteriv(GL.Enums.SGIX_sprite pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameteriv(GL.Enums.SGIX_sprite pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint GetInstruments()
|
|
{
|
|
return Delegates.glGetInstrumentsSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void InstrumentsBuffer(GLsizei size, GLint* buffer)
|
|
{
|
|
unsafe { Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer); }
|
|
}
|
|
|
|
public static
|
|
void InstrumentsBuffer(GLsizei size, GLint[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void InstrumentsBuffer(GLsizei size, out GLint buffer)
|
|
{
|
|
buffer = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLint PollInstruments(GLint* marker_p)
|
|
{
|
|
unsafe { return Delegates.glPollInstrumentsSGIX((GLint*)marker_p); }
|
|
}
|
|
|
|
public static
|
|
GLint PollInstruments(GLint[] marker_p)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* marker_p_ptr = marker_p)
|
|
{
|
|
GLint retval = Delegates.glPollInstrumentsSGIX((GLint*)marker_p_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint PollInstruments(out GLint marker_p)
|
|
{
|
|
marker_p = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* marker_p_ptr = &marker_p)
|
|
{
|
|
GLint retval = Delegates.glPollInstrumentsSGIX((GLint*)marker_p_ptr);
|
|
marker_p = *marker_p_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReadInstruments(GLint marker)
|
|
{
|
|
Delegates.glReadInstrumentsSGIX((GLint)marker);
|
|
}
|
|
|
|
public static
|
|
void StartInstruments()
|
|
{
|
|
Delegates.glStartInstrumentsSGIX();
|
|
}
|
|
|
|
public static
|
|
void StopInstruments(GLint marker)
|
|
{
|
|
Delegates.glStopInstrumentsSGIX((GLint)marker);
|
|
}
|
|
|
|
public static
|
|
void FrameZoom(GLint factor)
|
|
{
|
|
Delegates.glFrameZoomSGIX((GLint)factor);
|
|
}
|
|
|
|
public static
|
|
void TagSampleBuffer()
|
|
{
|
|
Delegates.glTagSampleBufferSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble* points)
|
|
{
|
|
unsafe { Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points); }
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = points)
|
|
{
|
|
Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, ref GLdouble points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* points_ptr = &points)
|
|
{
|
|
Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat* points)
|
|
{
|
|
unsafe { Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points); }
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = points)
|
|
{
|
|
Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, ref GLfloat points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* points_ptr = &points)
|
|
{
|
|
Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Deform(GL.Enums.FfdMaskSGIX mask)
|
|
{
|
|
Delegates.glDeformSGIX((GL.Enums.FfdMaskSGIX)mask);
|
|
}
|
|
|
|
public static
|
|
void LoadIdentityDeformationMap(GL.Enums.FfdMaskSGIX mask)
|
|
{
|
|
Delegates.glLoadIdentityDeformationMapSGIX((GL.Enums.FfdMaskSGIX)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReferencePlane(GLdouble* equation)
|
|
{
|
|
unsafe { Delegates.glReferencePlaneSGIX((GLdouble*)equation); }
|
|
}
|
|
|
|
public static
|
|
void ReferencePlane(GLdouble[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = equation)
|
|
{
|
|
Delegates.glReferencePlaneSGIX((GLdouble*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReferencePlane(ref GLdouble equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* equation_ptr = &equation)
|
|
{
|
|
Delegates.glReferencePlaneSGIX((GLdouble*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FlushRaster()
|
|
{
|
|
Delegates.glFlushRasterSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterf(Int32 list, GL.Enums.ListParameterName pname, GLfloat param)
|
|
{
|
|
Delegates.glListParameterfSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterf(GLuint list, GL.Enums.ListParameterName pname, GLfloat param)
|
|
{
|
|
Delegates.glListParameterfSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameteri(Int32 list, GL.Enums.ListParameterName pname, GLint param)
|
|
{
|
|
Delegates.glListParameteriSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameteri(GLuint list, GL.Enums.ListParameterName pname, GLint param)
|
|
{
|
|
Delegates.glListParameteriSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentColorMaterial(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
|
|
{
|
|
Delegates.glFragmentColorMaterialSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
|
|
}
|
|
|
|
public static
|
|
void FragmentLightf(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat param)
|
|
{
|
|
Delegates.glFragmentLightfSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLighti(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint param)
|
|
{
|
|
Delegates.glFragmentLightiSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelf(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat param)
|
|
{
|
|
Delegates.glFragmentLightModelfSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModeli(GL.Enums.FragmentLightModelParameterSGIX pname, GLint param)
|
|
{
|
|
Delegates.glFragmentLightModeliSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialf(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat param)
|
|
{
|
|
Delegates.glFragmentMaterialfSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMateriali(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint param)
|
|
{
|
|
Delegates.glFragmentMaterialiSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightEnvi(GL.Enums.LightEnvParameterSGIX pname, GLint param)
|
|
{
|
|
Delegates.glLightEnviSGIX((GL.Enums.LightEnvParameterSGIX)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void AsyncMarker(Int32 marker)
|
|
{
|
|
Delegates.glAsyncMarkerSGIX((GLuint)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AsyncMarker(GLuint marker)
|
|
{
|
|
Delegates.glAsyncMarkerSGIX((GLuint)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLint FinishAsync(Int32* markerp)
|
|
{
|
|
markerp = default(Int32*);
|
|
{
|
|
GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLint FinishAsync(GLuint* markerp)
|
|
{
|
|
unsafe { return Delegates.glFinishAsyncSGIX((GLuint*)markerp); }
|
|
}
|
|
|
|
public static
|
|
GLint FinishAsync(Int32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = markerp)
|
|
{
|
|
GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint FinishAsync(GLuint[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* markerp_ptr = markerp)
|
|
{
|
|
GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint FinishAsync(out Int32 markerp)
|
|
{
|
|
markerp = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = &markerp)
|
|
{
|
|
GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint FinishAsync(out GLuint markerp)
|
|
{
|
|
markerp = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* markerp_ptr = &markerp)
|
|
{
|
|
GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLint PollAsync(Int32* markerp)
|
|
{
|
|
markerp = default(Int32*);
|
|
{
|
|
GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLint PollAsync(GLuint* markerp)
|
|
{
|
|
unsafe { return Delegates.glPollAsyncSGIX((GLuint*)markerp); }
|
|
}
|
|
|
|
public static
|
|
GLint PollAsync(Int32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = markerp)
|
|
{
|
|
GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint PollAsync(GLuint[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* markerp_ptr = markerp)
|
|
{
|
|
GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLint PollAsync(out Int32 markerp)
|
|
{
|
|
markerp = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = &markerp)
|
|
{
|
|
GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint PollAsync(out GLuint markerp)
|
|
{
|
|
markerp = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* markerp_ptr = &markerp)
|
|
{
|
|
GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 GenAsyncMarkers(GLsizei range)
|
|
{
|
|
return Delegates.glGenAsyncMarkersSGIX((GLsizei)range);
|
|
}
|
|
|
|
public static
|
|
void DeleteAsyncMarkers(Int32 marker, GLsizei range)
|
|
{
|
|
Delegates.glDeleteAsyncMarkersSGIX((GLuint)marker, (GLsizei)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteAsyncMarkers(GLuint marker, GLsizei range)
|
|
{
|
|
Delegates.glDeleteAsyncMarkersSGIX((GLuint)marker, (GLsizei)range);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsAsyncMarker(Int32 marker)
|
|
{
|
|
return Delegates.glIsAsyncMarkerSGIX((GLuint)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsAsyncMarker(GLuint marker)
|
|
{
|
|
return Delegates.glIsAsyncMarkerSGIX((GLuint)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IglooInterface(GL.Enums.GLenum pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glIglooInterfaceSGIX((GL.Enums.GLenum)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void IglooInterface(GL.Enums.GLenum pname, object @params)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glIglooInterfaceSGIX((GL.Enums.GLenum)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class HP
|
|
{
|
|
public static
|
|
void ImageTransformParameteri(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint param)
|
|
{
|
|
Delegates.glImageTransformParameteriHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterf(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat param)
|
|
{
|
|
Delegates.glImageTransformParameterfHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class PGI
|
|
{
|
|
public static
|
|
void Hint(GL.Enums.PGI_misc_hints target, GLint mode)
|
|
{
|
|
Delegates.glHintPGI((GL.Enums.PGI_misc_hints)target, (GLint)mode);
|
|
}
|
|
|
|
}
|
|
|
|
public static class SUNX
|
|
{
|
|
public static
|
|
void FinishTexture()
|
|
{
|
|
Delegates.glFinishTextureSUNX();
|
|
}
|
|
|
|
}
|
|
|
|
public static class SUN
|
|
{
|
|
public static
|
|
void GlobalAlphaFactorb(Byte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorbSUN((GLbyte)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactorb(GLbyte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorbSUN((GLbyte)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactors(GLshort factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorsSUN((GLshort)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactori(GLint factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoriSUN((GLint)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorf(GLfloat factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorfSUN((GLfloat)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactord(GLdouble factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactordSUN((GLdouble)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorub(GLubyte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorubSUN((GLubyte)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorus(Int16 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorusSUN((GLushort)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactorus(GLushort factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorusSUN((GLushort)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorui(Int32 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoruiSUN((GLuint)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactorui(GLuint factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoruiSUN((GLuint)factor);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeui(Int32 code)
|
|
{
|
|
Delegates.glReplacementCodeuiSUN((GLuint)code);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeui(GLuint code)
|
|
{
|
|
Delegates.glReplacementCodeuiSUN((GLuint)code);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeus(Int16 code)
|
|
{
|
|
Delegates.glReplacementCodeusSUN((GLushort)code);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeus(GLushort code)
|
|
{
|
|
Delegates.glReplacementCodeusSUN((GLushort)code);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeub(GLubyte code)
|
|
{
|
|
Delegates.glReplacementCodeubSUN((GLubyte)code);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiv(Int32* code)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((GLuint*)code);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiv(GLuint* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuivSUN((GLuint*)code); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiv(Int32[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiv(GLuint[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiv(ref Int32 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiv(ref GLuint code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeusv(Int16* code)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((GLushort*)code);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeusv(GLushort* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeusvSUN((GLushort*)code); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeusv(Int16[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeusv(GLushort[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeusv(ref Int16 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeusv(ref GLushort code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLushort* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeubv(GLubyte* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeubvSUN((GLubyte*)code); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeubv(GLubyte[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeubvSUN((GLubyte*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeubv(ref GLubyte code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeubvSUN((GLubyte*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodePointer(GL.Enums.SUN_triangle_list type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glReplacementCodePointerSUN((GL.Enums.SUN_triangle_list)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodePointer(GL.Enums.SUN_triangle_list type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glReplacementCodePointerSUN((GL.Enums.SUN_triangle_list)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2f(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glColor4ubVertex2fSUN((GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2fv(GLubyte* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2fv(GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2fv(GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2fv(GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2fv(GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2fv(GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2fv(ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2fv(ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2fv(ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3f(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glColor4ubVertex3fSUN((GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3fv(GLubyte* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3fv(GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3fv(GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3fv(GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3fv(GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3fv(GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3fv(ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3fv(ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3fv(ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3f(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glColor3fVertex3fSUN((GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3fv(GLfloat* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3fv(GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3fv(GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3fv(GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3fv(GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3fv(GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3fv(ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3fv(ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3fv(ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3f(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glNormal3fVertex3fSUN((GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3fv(GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3fv(GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3fv(GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3fv(GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3fv(GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3fv(GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3fv(ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3fv(ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3fv(ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3f(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fSUN((GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3f(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3fv(GLfloat* tc, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3fv(GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3fv(GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3fv(GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3fv(GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3fv(GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3fv(ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3fv(ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3fv(ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4f(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fSUN((GLfloat)s, (GLfloat)t, (GLfloat)p, (GLfloat)q, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4fv(GLfloat* tc, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4fv(GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4fv(GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4fv(GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4fv(GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4fv(GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4fv(ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4fv(ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4fv(ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3f(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fSUN((GLfloat)s, (GLfloat)t, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3f(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3f(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3f(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4f(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN((GLfloat)s, (GLfloat)t, (GLfloat)p, (GLfloat)q, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3f(Int32 rc, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fSUN((GLuint)rc, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3f(GLuint rc, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fSUN((GLuint)rc, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(Int32* rc, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(Int32* rc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(Int32* rc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(Int32[] rc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(GLuint[] rc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(Int32[] rc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(GLuint[] rc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(Int32[] rc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(GLuint[] rc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(ref Int32 rc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3fv(ref GLuint rc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(ref Int32 rc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(ref GLuint rc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(ref Int32 rc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3fv(ref GLuint rc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3f(Int32 rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fSUN((GLuint)rc, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3f(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fSUN((GLuint)rc, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLubyte* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3f(Int32 rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3f(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3f(Int32 rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fSUN((GLuint)rc, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3f(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fSUN((GLuint)rc, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3f(Int32 rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3f(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* rc_ptr = &rc)
|
|
fixed (GLfloat* tc_ptr = &tc)
|
|
fixed (GLfloat* c_ptr = &c)
|
|
fixed (GLfloat* n_ptr = &n)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawMeshArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width)
|
|
{
|
|
Delegates.glDrawMeshArraysSUN((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count, (GLsizei)width);
|
|
}
|
|
|
|
}
|
|
|
|
public static class INGR
|
|
{
|
|
public static
|
|
void BlendFuncSeparate(GL.Enums.GLenum sfactorRGB, GL.Enums.GLenum dfactorRGB, GL.Enums.GLenum sfactorAlpha, GL.Enums.GLenum dfactorAlpha)
|
|
{
|
|
Delegates.glBlendFuncSeparateINGR((GL.Enums.GLenum)sfactorRGB, (GL.Enums.GLenum)dfactorRGB, (GL.Enums.GLenum)sfactorAlpha, (GL.Enums.GLenum)dfactorAlpha);
|
|
}
|
|
|
|
}
|
|
|
|
public static class NV
|
|
{
|
|
public static
|
|
void FlushVertexArrayRange()
|
|
{
|
|
Delegates.glFlushVertexArrayRangeNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexArrayRange(GLsizei length, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexArrayRangeNV((GLsizei)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexArrayRange(GLsizei length, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexArrayRangeNV((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CombinerParameterfv(GL.Enums.NV_register_combiners pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterfv(GL.Enums.NV_register_combiners pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterfv(GL.Enums.NV_register_combiners pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterf(GL.Enums.NV_register_combiners pname, GLfloat param)
|
|
{
|
|
Delegates.glCombinerParameterfNV((GL.Enums.NV_register_combiners)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CombinerParameteriv(GL.Enums.NV_register_combiners pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerParameteriv(GL.Enums.NV_register_combiners pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameteriv(GL.Enums.NV_register_combiners pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameteri(GL.Enums.NV_register_combiners pname, GLint param)
|
|
{
|
|
Delegates.glCombinerParameteriNV((GL.Enums.NV_register_combiners)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void CombinerInput(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners input, GL.Enums.NV_register_combiners mapping, GL.Enums.NV_register_combiners componentUsage)
|
|
{
|
|
Delegates.glCombinerInputNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)input, (GL.Enums.NV_register_combiners)mapping, (GL.Enums.NV_register_combiners)componentUsage);
|
|
}
|
|
|
|
public static
|
|
void CombinerOutput(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners abOutput, GL.Enums.NV_register_combiners cdOutput, GL.Enums.NV_register_combiners sumOutput, GL.Enums.NV_register_combiners scale, GL.Enums.NV_register_combiners bias, GL.Enums.Boolean abDotProduct, GL.Enums.Boolean cdDotProduct, GL.Enums.Boolean muxSum)
|
|
{
|
|
Delegates.glCombinerOutputNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)abOutput, (GL.Enums.NV_register_combiners)cdOutput, (GL.Enums.NV_register_combiners)sumOutput, (GL.Enums.NV_register_combiners)scale, (GL.Enums.NV_register_combiners)bias, (GL.Enums.Boolean)abDotProduct, (GL.Enums.Boolean)cdDotProduct, (GL.Enums.Boolean)muxSum);
|
|
}
|
|
|
|
public static
|
|
void FinalCombinerInput(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners input, GL.Enums.NV_register_combiners mapping, GL.Enums.NV_register_combiners componentUsage)
|
|
{
|
|
Delegates.glFinalCombinerInputNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)input, (GL.Enums.NV_register_combiners)mapping, (GL.Enums.NV_register_combiners)componentUsage);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFences(GLsizei n, Int32* fences)
|
|
{
|
|
{
|
|
Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFences(GLsizei n, GLuint* fences)
|
|
{
|
|
unsafe { Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences); }
|
|
}
|
|
|
|
public static
|
|
void DeleteFences(GLsizei n, Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFences(GLsizei n, GLuint[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFences(GLsizei n, ref Int32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFences(GLsizei n, ref GLuint fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFences(GLsizei n, Int32* fences)
|
|
{
|
|
fences = default(Int32*);
|
|
{
|
|
Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFences(GLsizei n, GLuint* fences)
|
|
{
|
|
unsafe { Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences); }
|
|
}
|
|
|
|
public static
|
|
void GenFences(GLsizei n, Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFences(GLsizei n, GLuint[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFences(GLsizei n, out Int32 fences)
|
|
{
|
|
fences = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFences(GLsizei n, out GLuint fences)
|
|
{
|
|
fences = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsFence(Int32 fence)
|
|
{
|
|
return Delegates.glIsFenceNV((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsFence(GLuint fence)
|
|
{
|
|
return Delegates.glIsFenceNV((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
GLboolean TestFence(Int32 fence)
|
|
{
|
|
return Delegates.glTestFenceNV((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean TestFence(GLuint fence)
|
|
{
|
|
return Delegates.glTestFenceNV((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FinishFence(Int32 fence)
|
|
{
|
|
Delegates.glFinishFenceNV((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FinishFence(GLuint fence)
|
|
{
|
|
Delegates.glFinishFenceNV((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
void SetFence(Int32 fence, GL.Enums.NV_fence condition)
|
|
{
|
|
Delegates.glSetFenceNV((GLuint)fence, (GL.Enums.NV_fence)condition);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFence(GLuint fence, GL.Enums.NV_fence condition)
|
|
{
|
|
Delegates.glSetFenceNV((GLuint)fence, (GL.Enums.NV_fence)condition);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapControlPoints(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
{
|
|
Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GLint)uorder, (GLint)vorder, (GL.Enums.Boolean)packed, (void*)points);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapControlPoints(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
unsafe { Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GLint)uorder, (GLint)vorder, (GL.Enums.Boolean)packed, (void*)points); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapControlPoints(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
points = default(void*);
|
|
{
|
|
Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GL.Enums.Boolean)packed, (void*)points);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapControlPoints(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
unsafe { Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GL.Enums.Boolean)packed, (void*)points); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalMaps(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators mode)
|
|
{
|
|
Delegates.glEvalMapsNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, Int32* programs, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, GLuint* programs, GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, Int32[] programs, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, GLuint[] programs, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, ref Int32 programs, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe GLboolean AreProgramsResident(GLsizei n, ref GLuint programs, GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindProgram(GL.Enums.NV_vertex_program target, Int32 id)
|
|
{
|
|
Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindProgram(GL.Enums.NV_vertex_program target, GLuint id)
|
|
{
|
|
Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeletePrograms(GLsizei n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeletePrograms(GLsizei n, GLuint* programs)
|
|
{
|
|
unsafe { Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs); }
|
|
}
|
|
|
|
public static
|
|
void DeletePrograms(GLsizei n, Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeletePrograms(GLsizei n, GLuint[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeletePrograms(GLsizei n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeletePrograms(GLsizei n, ref GLuint programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenPrograms(GLsizei n, Int32* programs)
|
|
{
|
|
programs = default(Int32*);
|
|
{
|
|
Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenPrograms(GLsizei n, GLuint* programs)
|
|
{
|
|
unsafe { Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs); }
|
|
}
|
|
|
|
public static
|
|
void GenPrograms(GLsizei n, Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenPrograms(GLsizei n, GLuint[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenPrograms(GLsizei n, out Int32 programs)
|
|
{
|
|
programs = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenPrograms(GLsizei n, out GLuint programs)
|
|
{
|
|
programs = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, GLubyte* program)
|
|
{
|
|
program = default(GLubyte*);
|
|
{
|
|
Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, GLubyte* program)
|
|
{
|
|
unsafe { Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, GLubyte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = program)
|
|
{
|
|
Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, GLubyte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = program)
|
|
{
|
|
Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, out GLubyte program)
|
|
{
|
|
program = default(GLubyte);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = &program)
|
|
{
|
|
Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
|
|
program = *program_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, out GLubyte program)
|
|
{
|
|
program = default(GLubyte);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = &program)
|
|
{
|
|
Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
|
|
program = *program_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.NV_vertex_program pname, void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.NV_vertex_program pname, void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointerv(Int32 index, GL.Enums.NV_vertex_program pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointerv(GLuint index, GL.Enums.NV_vertex_program pname, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsProgram(Int32 id)
|
|
{
|
|
return Delegates.glIsProgramNV((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsProgram(GLuint id)
|
|
{
|
|
return Delegates.glIsProgramNV((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, GLubyte* program)
|
|
{
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, GLubyte* program)
|
|
{
|
|
unsafe { Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program); }
|
|
}
|
|
|
|
public static
|
|
void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, GLubyte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, GLubyte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, ref GLubyte program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = &program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, ref GLubyte program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* program_ptr = &program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4d(GL.Enums.NV_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4d(GL.Enums.NV_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4f(GL.Enums.NV_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4f(GL.Enums.NV_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RequestResidentPrograms(GLsizei n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RequestResidentPrograms(GLsizei n, GLuint* programs)
|
|
{
|
|
unsafe { Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs); }
|
|
}
|
|
|
|
public static
|
|
void RequestResidentPrograms(GLsizei n, Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void RequestResidentPrograms(GLsizei n, GLuint[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RequestResidentPrograms(GLsizei n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void RequestResidentPrograms(GLsizei n, ref GLuint programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* programs_ptr = &programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TrackMatrix(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program matrix, GL.Enums.NV_vertex_program transform)
|
|
{
|
|
Delegates.glTrackMatrixNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TrackMatrix(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program matrix, GL.Enums.NV_vertex_program transform)
|
|
{
|
|
Delegates.glTrackMatrixNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(Int32 index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(GLuint index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribPointer(Int32 index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribPointer(GLuint index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1d(Int32 index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1dNV((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1d(GLuint index, GLdouble x)
|
|
{
|
|
Delegates.glVertexAttrib1dNV((GLuint)index, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1f(Int32 index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1fNV((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1f(GLuint index, GLfloat x)
|
|
{
|
|
Delegates.glVertexAttrib1fNV((GLuint)index, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1s(Int32 index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1sNV((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1s(GLuint index, GLshort x)
|
|
{
|
|
Delegates.glVertexAttrib1sNV((GLuint)index, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2dNV((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexAttrib2dNV((GLuint)index, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2fNV((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexAttrib2fNV((GLuint)index, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2sNV((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexAttrib2sNV((GLuint)index, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexAttrib3dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexAttrib3fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexAttrib3sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexAttrib4dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4dv(Int32 index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4dv(GLuint index, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexAttrib4fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4fv(Int32 index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4fv(GLuint index, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexAttrib4sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4sv(Int32 index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4sv(GLuint index, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4ubNV((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
Delegates.glVertexAttrib4ubNV((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4ubv(Int32 index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4ubv(GLuint index, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1dv(Int32 index, GLsizei count, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1dv(GLuint index, GLsizei count, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1dv(Int32 index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1dv(GLuint index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1dv(Int32 index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1dv(GLuint index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1fv(Int32 index, GLsizei count, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1fv(GLuint index, GLsizei count, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1fv(Int32 index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1fv(GLuint index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1fv(Int32 index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1fv(GLuint index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1sv(Int32 index, GLsizei count, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1sv(GLuint index, GLsizei count, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1sv(Int32 index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1sv(GLuint index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1sv(Int32 index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1sv(GLuint index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2dv(Int32 index, GLsizei count, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2dv(GLuint index, GLsizei count, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2dv(Int32 index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2dv(GLuint index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2dv(Int32 index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2dv(GLuint index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2fv(Int32 index, GLsizei count, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2fv(GLuint index, GLsizei count, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2fv(Int32 index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2fv(GLuint index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2fv(Int32 index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2fv(GLuint index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2sv(Int32 index, GLsizei count, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2sv(GLuint index, GLsizei count, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2sv(Int32 index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2sv(GLuint index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2sv(Int32 index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2sv(GLuint index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3dv(Int32 index, GLsizei count, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3dv(GLuint index, GLsizei count, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3dv(Int32 index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3dv(GLuint index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3dv(Int32 index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3dv(GLuint index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3fv(Int32 index, GLsizei count, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3fv(GLuint index, GLsizei count, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3fv(Int32 index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3fv(GLuint index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3fv(Int32 index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3fv(GLuint index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3sv(Int32 index, GLsizei count, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3sv(GLuint index, GLsizei count, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3sv(Int32 index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3sv(GLuint index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3sv(Int32 index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3sv(GLuint index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4dv(Int32 index, GLsizei count, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4dv(GLuint index, GLsizei count, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4dv(Int32 index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4dv(GLuint index, GLsizei count, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4dv(Int32 index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4dv(GLuint index, GLsizei count, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4fv(Int32 index, GLsizei count, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4fv(GLuint index, GLsizei count, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4fv(Int32 index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4fv(GLuint index, GLsizei count, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4fv(Int32 index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4fv(GLuint index, GLsizei count, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4sv(Int32 index, GLsizei count, GLshort* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4sv(GLuint index, GLsizei count, GLshort* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4sv(Int32 index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4sv(GLuint index, GLsizei count, GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4sv(Int32 index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4sv(GLuint index, GLsizei count, ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4ubv(Int32 index, GLsizei count, GLubyte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4ubv(GLuint index, GLsizei count, GLubyte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4ubv(Int32 index, GLsizei count, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4ubv(GLuint index, GLsizei count, GLubyte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4ubv(Int32 index, GLsizei count, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4ubv(GLuint index, GLsizei count, ref GLubyte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenOcclusionQueries(GLsizei n, Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenOcclusionQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void GenOcclusionQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenOcclusionQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenOcclusionQueries(GLsizei n, out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenOcclusionQueries(GLsizei n, out GLuint ids)
|
|
{
|
|
ids = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteOcclusionQueries(GLsizei n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteOcclusionQueries(GLsizei n, GLuint* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids); }
|
|
}
|
|
|
|
public static
|
|
void DeleteOcclusionQueries(GLsizei n, Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteOcclusionQueries(GLsizei n, GLuint[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteOcclusionQueries(GLsizei n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteOcclusionQueries(GLsizei n, ref GLuint ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsOcclusionQuery(Int32 id)
|
|
{
|
|
return Delegates.glIsOcclusionQueryNV((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsOcclusionQuery(GLuint id)
|
|
{
|
|
return Delegates.glIsOcclusionQueryNV((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void BeginOcclusionQuery(Int32 id)
|
|
{
|
|
Delegates.glBeginOcclusionQueryNV((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginOcclusionQuery(GLuint id)
|
|
{
|
|
Delegates.glBeginOcclusionQueryNV((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void EndOcclusionQuery()
|
|
{
|
|
Delegates.glEndOcclusionQueryNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteri(GL.Enums.NV_point_sprite pname, GLint param)
|
|
{
|
|
Delegates.glPointParameteriNV((GL.Enums.NV_point_sprite)pname, (GLint)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameteriv(GL.Enums.NV_point_sprite pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameteriv(GL.Enums.NV_point_sprite pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteriv(GL.Enums.NV_point_sprite pname, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4f(Int32 id, GLsizei len, GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4f(GLuint id, GLsizei len, GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w); }
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4f(Int32 id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4f(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4f(Int32 id, GLsizei len, ref GLubyte name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4f(GLuint id, GLsizei len, ref GLubyte name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4d(Int32 id, GLsizei len, GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4d(GLuint id, GLsizei len, GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w); }
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4d(Int32 id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4d(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4d(Int32 id, GLsizei len, ref GLubyte name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4d(GLuint id, GLsizei len, ref GLubyte name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, GLfloat* v)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, GLfloat[] v)
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, ref GLfloat v)
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, GLfloat* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, GLdouble* v)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, GLdouble[] v)
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, GLdouble[] v)
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, ref GLdouble v)
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, ref GLdouble v)
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, GLdouble* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, GLdouble* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, GLdouble* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, GLdouble* v)
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, GLfloat[] @params)
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, GLfloat[] @params)
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, GLdouble* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, GLdouble[] @params)
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, GLdouble[] @params)
|
|
{
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
fixed (GLubyte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = name)
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, GLdouble* @params)
|
|
{
|
|
@params = default(GLdouble*);
|
|
fixed (GLubyte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, out GLdouble @params)
|
|
{
|
|
@params = default(GLdouble);
|
|
unsafe
|
|
{
|
|
fixed (GLubyte* name_ptr = &name)
|
|
fixed (GLdouble* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2h(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertex2hNV((GLhalfNV)x, (GLhalfNV)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2h(GLhalfNV x, GLhalfNV y)
|
|
{
|
|
Delegates.glVertex2hNV((GLhalfNV)x, (GLhalfNV)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex2hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertex2hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3h(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertex3hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3h(GLhalfNV x, GLhalfNV y, GLhalfNV z)
|
|
{
|
|
Delegates.glVertex3hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex3hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertex3hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4h(Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertex4hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4h(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
|
|
{
|
|
Delegates.glVertex4hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex4hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertex4hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3h(Int16 nx, Int16 ny, Int16 nz)
|
|
{
|
|
Delegates.glNormal3hNV((GLhalfNV)nx, (GLhalfNV)ny, (GLhalfNV)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3h(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)
|
|
{
|
|
Delegates.glNormal3hNV((GLhalfNV)nx, (GLhalfNV)ny, (GLhalfNV)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glNormal3hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glNormal3hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3h(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3h(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
|
|
{
|
|
Delegates.glColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor3hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glColor3hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4h(Int16 red, Int16 green, Int16 blue, Int16 alpha)
|
|
{
|
|
Delegates.glColor4hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue, (GLhalfNV)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4h(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)
|
|
{
|
|
Delegates.glColor4hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue, (GLhalfNV)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor4hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glColor4hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1h(Int16 s)
|
|
{
|
|
Delegates.glTexCoord1hNV((GLhalfNV)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1h(GLhalfNV s)
|
|
{
|
|
Delegates.glTexCoord1hNV((GLhalfNV)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord1hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2h(Int16 s, Int16 t)
|
|
{
|
|
Delegates.glTexCoord2hNV((GLhalfNV)s, (GLhalfNV)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2h(GLhalfNV s, GLhalfNV t)
|
|
{
|
|
Delegates.glTexCoord2hNV((GLhalfNV)s, (GLhalfNV)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord2hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3h(Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glTexCoord3hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3h(GLhalfNV s, GLhalfNV t, GLhalfNV r)
|
|
{
|
|
Delegates.glTexCoord3hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord3hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4h(Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glTexCoord4hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4h(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
|
|
{
|
|
Delegates.glTexCoord4hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord4hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1h(GL.Enums.NV_half_float target, Int16 s)
|
|
{
|
|
Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1h(GL.Enums.NV_half_float target, GLhalfNV s)
|
|
{
|
|
Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1hv(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1hv(GL.Enums.NV_half_float target, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1hv(GL.Enums.NV_half_float target, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1hv(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2h(GL.Enums.NV_half_float target, Int16 s, Int16 t)
|
|
{
|
|
Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t)
|
|
{
|
|
Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2hv(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2hv(GL.Enums.NV_half_float target, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2hv(GL.Enums.NV_half_float target, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2hv(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3h(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r)
|
|
{
|
|
Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3hv(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3hv(GL.Enums.NV_half_float target, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3hv(GL.Enums.NV_half_float target, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3hv(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4h(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
|
|
{
|
|
Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4hv(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4hv(GL.Enums.NV_half_float target, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4hv(GL.Enums.NV_half_float target, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4hv(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordh(Int16 fog)
|
|
{
|
|
Delegates.glFogCoordhNV((GLhalfNV)fog);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordh(GLhalfNV fog)
|
|
{
|
|
Delegates.glFogCoordhNV((GLhalfNV)fog);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordhv(Int16* fog)
|
|
{
|
|
{
|
|
Delegates.glFogCoordhvNV((GLhalfNV*)fog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordhv(GLhalfNV* fog)
|
|
{
|
|
unsafe { Delegates.glFogCoordhvNV((GLhalfNV*)fog); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordhv(Int16[] fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* fog_ptr = fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordhv(GLhalfNV[] fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* fog_ptr = fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordhv(ref Int16 fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* fog_ptr = &fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordhv(ref GLhalfNV fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* fog_ptr = &fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3h(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3h(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
|
|
{
|
|
Delegates.glSecondaryColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3hv(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3hv(GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3hvNV((GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3hv(Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3hv(GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3hv(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3hv(ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeighth(Int16 weight)
|
|
{
|
|
Delegates.glVertexWeighthNV((GLhalfNV)weight);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighth(GLhalfNV weight)
|
|
{
|
|
Delegates.glVertexWeighthNV((GLhalfNV)weight);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeighthv(Int16* weight)
|
|
{
|
|
{
|
|
Delegates.glVertexWeighthvNV((GLhalfNV*)weight);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeighthv(GLhalfNV* weight)
|
|
{
|
|
unsafe { Delegates.glVertexWeighthvNV((GLhalfNV*)weight); }
|
|
}
|
|
|
|
public static
|
|
void VertexWeighthv(Int16[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighthv(GLhalfNV[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeighthv(ref Int16 weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighthv(ref GLhalfNV weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1h(Int32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1hNV((GLuint)index, (GLhalfNV)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1h(GLuint index, GLhalfNV x)
|
|
{
|
|
Delegates.glVertexAttrib1hNV((GLuint)index, (GLhalfNV)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1hv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1hv(GLuint index, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1hv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1hv(GLuint index, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1hv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1hv(GLuint index, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2h(Int32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2h(GLuint index, GLhalfNV x, GLhalfNV y)
|
|
{
|
|
Delegates.glVertexAttrib2hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2hv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2hv(GLuint index, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2hv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2hv(GLuint index, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2hv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2hv(GLuint index, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3h(Int32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3h(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
|
|
{
|
|
Delegates.glVertexAttrib3hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3hv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3hv(GLuint index, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3hv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3hv(GLuint index, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3hv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3hv(GLuint index, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4h(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4h(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
|
|
{
|
|
Delegates.glVertexAttrib4hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4hv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4hv(GLuint index, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4hv(Int32 index, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4hv(GLuint index, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4hv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4hv(GLuint index, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1hv(Int32 index, GLsizei n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1hv(GLuint index, GLsizei n, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1hv(Int32 index, GLsizei n, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1hv(GLuint index, GLsizei n, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1hv(Int32 index, GLsizei n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1hv(GLuint index, GLsizei n, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2hv(Int32 index, GLsizei n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2hv(GLuint index, GLsizei n, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2hv(Int32 index, GLsizei n, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2hv(GLuint index, GLsizei n, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2hv(Int32 index, GLsizei n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2hv(GLuint index, GLsizei n, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3hv(Int32 index, GLsizei n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3hv(GLuint index, GLsizei n, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3hv(Int32 index, GLsizei n, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3hv(GLuint index, GLsizei n, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3hv(Int32 index, GLsizei n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3hv(GLuint index, GLsizei n, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4hv(Int32 index, GLsizei n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4hv(GLuint index, GLsizei n, GLhalfNV* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4hv(Int32 index, GLsizei n, Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4hv(GLuint index, GLsizei n, GLhalfNV[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4hv(Int32 index, GLsizei n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4hv(GLuint index, GLsizei n, ref GLhalfNV v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLhalfNV* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelDataRange(GL.Enums.NV_pixel_data_range target, GLsizei length, void* pointer)
|
|
{
|
|
unsafe { Delegates.glPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target, (GLsizei)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void PixelDataRange(GL.Enums.NV_pixel_data_range target, GLsizei length, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target, (GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FlushPixelDataRange(GL.Enums.NV_pixel_data_range target)
|
|
{
|
|
Delegates.glFlushPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target);
|
|
}
|
|
|
|
public static
|
|
void PrimitiveRestart()
|
|
{
|
|
Delegates.glPrimitiveRestartNV();
|
|
}
|
|
|
|
public static
|
|
void PrimitiveRestartIndex(Int32 index)
|
|
{
|
|
Delegates.glPrimitiveRestartIndexNV((GLuint)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrimitiveRestartIndex(GLuint index)
|
|
{
|
|
Delegates.glPrimitiveRestartIndexNV((GLuint)index);
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4i(GL.Enums.NV_gpu_program4 target, Int32 index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4i(GL.Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4ui(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4ui(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4i(GL.Enums.NV_gpu_program4 target, Int32 index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4i(GL.Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4ui(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4ui(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
|
|
{
|
|
@params = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramVertexLimit(GL.Enums.NV_geometry_program4 target, GLint limit)
|
|
{
|
|
Delegates.glProgramVertexLimitNV((GL.Enums.NV_geometry_program4)target, (GLint)limit);
|
|
}
|
|
|
|
public static
|
|
void DepthRanged(GLdouble zNear, GLdouble zFar)
|
|
{
|
|
Delegates.glDepthRangedNV((GLdouble)zNear, (GLdouble)zFar);
|
|
}
|
|
|
|
public static
|
|
void ClearDepthd(GLdouble depth)
|
|
{
|
|
Delegates.glClearDepthdNV((GLdouble)depth);
|
|
}
|
|
|
|
public static
|
|
void DepthBoundsd(GLdouble zmin, GLdouble zmax)
|
|
{
|
|
Delegates.glDepthBoundsdNV((GLdouble)zmin, (GLdouble)zmax);
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorageMultisampleCoverage(GL.Enums.NV_framebuffer_multisample_coverage target, GLsizei coverageSamples, GLsizei colorSamples, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height)
|
|
{
|
|
Delegates.glRenderbufferStorageMultisampleCoverageNV((GL.Enums.NV_framebuffer_multisample_coverage)target, (GLsizei)coverageSamples, (GLsizei)colorSamples, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLfloat* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLfloat @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLint* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLuint* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLuint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLuint @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BeginTransformFeedback(GL.Enums.NV_transform_feedback primitiveMode)
|
|
{
|
|
Delegates.glBeginTransformFeedbackNV((GL.Enums.NV_transform_feedback)primitiveMode);
|
|
}
|
|
|
|
public static
|
|
void EndTransformFeedback()
|
|
{
|
|
Delegates.glEndTransformFeedbackNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackAttribs(Int32 count, GLint* attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackAttribs(GLuint count, GLint* attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe { Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs, (GL.Enums.NV_transform_feedback)bufferMode); }
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackAttribs(Int32 count, GLint[] attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* attribs_ptr = attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackAttribs(GLuint count, GLint[] attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* attribs_ptr = attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackAttribs(Int32 count, ref GLint attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* attribs_ptr = &attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackAttribs(GLuint count, ref GLint attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* attribs_ptr = &attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BindBufferRange(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, GLintptr offset, GLsizeiptr size)
|
|
{
|
|
Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset, (GLsizeiptr)size);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferRange(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
|
|
{
|
|
Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset, (GLsizeiptr)size);
|
|
}
|
|
|
|
public static
|
|
void BindBufferOffset(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, GLintptr offset)
|
|
{
|
|
Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferOffset(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer, GLintptr offset)
|
|
{
|
|
Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset);
|
|
}
|
|
|
|
public static
|
|
void BindBufferBase(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer)
|
|
{
|
|
Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferBase(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer)
|
|
{
|
|
Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackVaryings(Int32 program, GLsizei count, GLint* locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackVaryings(GLuint program, GLsizei count, GLint* locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe { Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations, (GL.Enums.NV_transform_feedback)bufferMode); }
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackVaryings(Int32 program, GLsizei count, GLint[] locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* locations_ptr = locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackVaryings(GLuint program, GLsizei count, GLint[] locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* locations_ptr = locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackVaryings(Int32 program, GLsizei count, ref GLint locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* locations_ptr = &locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackVaryings(GLuint program, GLsizei count, ref GLint locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* locations_ptr = &locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ActiveVarying(Int32 program, System.String name)
|
|
{
|
|
Delegates.glActiveVaryingNV((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ActiveVarying(GLuint program, System.String name)
|
|
{
|
|
Delegates.glActiveVaryingNV((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
GLint GetVaryingLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetVaryingLocationNV((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLint GetVaryingLocation(GLuint program, System.String name)
|
|
{
|
|
return Delegates.glGetVaryingLocationNV((GLuint)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei*);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
|
|
{
|
|
length = default(GLsizei);
|
|
size = default(GLsizei);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (GLsizei* length_ptr = &length)
|
|
fixed (GLsizei* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTransformFeedbackVarying(Int32 program, Int32 index, GLint* location)
|
|
{
|
|
location = default(GLint*);
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTransformFeedbackVarying(GLuint program, GLuint index, GLint* location)
|
|
{
|
|
unsafe { Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location); }
|
|
}
|
|
|
|
public static
|
|
void GetTransformFeedbackVarying(Int32 program, Int32 index, GLint[] location)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* location_ptr = location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTransformFeedbackVarying(GLuint program, GLuint index, GLint[] location)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* location_ptr = location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTransformFeedbackVarying(Int32 program, Int32 index, out GLint location)
|
|
{
|
|
location = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* location_ptr = &location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
|
|
location = *location_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTransformFeedbackVarying(GLuint program, GLuint index, out GLint location)
|
|
{
|
|
location = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* location_ptr = &location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
|
|
location = *location_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class MESA
|
|
{
|
|
public static
|
|
void ResizeBuffers()
|
|
{
|
|
Delegates.glResizeBuffersMESA();
|
|
}
|
|
|
|
public static
|
|
void WindowPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glWindowPos2dMESA((GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dvMESA((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glWindowPos2fMESA((GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fvMESA((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2i(GLint x, GLint y)
|
|
{
|
|
Delegates.glWindowPos2iMESA((GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2ivMESA((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2s(GLshort x, GLshort y)
|
|
{
|
|
Delegates.glWindowPos2sMESA((GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2svMESA((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glWindowPos3dMESA((GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dvMESA((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glWindowPos3fMESA((GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fvMESA((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glWindowPos3iMESA((GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3ivMESA((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glWindowPos3sMESA((GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3svMESA((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glWindowPos4dMESA((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4dv(GLdouble* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4dvMESA((GLdouble*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4dv(GLdouble[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4dv(ref GLdouble v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4dvMESA((GLdouble*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glWindowPos4fMESA((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4fv(GLfloat* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4fvMESA((GLfloat*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4fv(GLfloat[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4fv(ref GLfloat v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4fvMESA((GLfloat*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glWindowPos4iMESA((GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4iv(GLint* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4ivMESA((GLint*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4iv(GLint[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4iv(ref GLint v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4ivMESA((GLint*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glWindowPos4sMESA((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4sv(GLshort* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4svMESA((GLshort*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4sv(GLshort[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4sv(ref GLshort v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4svMESA((GLshort*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class IBM
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe { Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
unsafe { Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (GLsizei* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (GLsizei* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElements(GL.Enums.BeginMode[] mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElements(ref GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointerList(GLint size, GL.Enums.ColorPointerType type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glColorPointerListIBM((GLint)size, (GL.Enums.ColorPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointerList(GLint size, GL.Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointerListIBM((GLint)size, (GL.Enums.ColorPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointerList(GLint size, GL.Enums.IBM_vertex_array_lists type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointerListIBM((GLint)size, (GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointerList(GLint size, GL.Enums.IBM_vertex_array_lists type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointerListIBM((GLint)size, (GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointerList(GLint stride, GLboolean* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointerListIBM((GLint)stride, (GLboolean*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointerList(GL.Enums.IBM_vertex_array_lists type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointerListIBM((GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointerList(GL.Enums.IBM_vertex_array_lists type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glFogCoordPointerListIBM((GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IndexPointerList(GL.Enums.IndexPointerType type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glIndexPointerListIBM((GL.Enums.IndexPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointerList(GL.Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glIndexPointerListIBM((GL.Enums.IndexPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointerList(GL.Enums.NormalPointerType type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glNormalPointerListIBM((GL.Enums.NormalPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointerList(GL.Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glNormalPointerListIBM((GL.Enums.NormalPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointerList(GLint size, GL.Enums.TexCoordPointerType type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointerListIBM((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointerList(GLint size, GL.Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointerListIBM((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointerList(GLint size, GL.Enums.VertexPointerType type, GLint stride, void* pointer, GLint ptrstride)
|
|
{
|
|
unsafe { Delegates.glVertexPointerListIBM((GLint)size, (GL.Enums.VertexPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointerList(GLint size, GL.Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointerListIBM((GLint)size, (GL.Enums.VertexPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class ATI
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint* param)
|
|
{
|
|
unsafe { Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param); }
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* param_ptr = param)
|
|
{
|
|
Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, ref GLint param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* param_ptr = ¶m)
|
|
{
|
|
Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat* param)
|
|
{
|
|
unsafe { Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param); }
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* param_ptr = param)
|
|
{
|
|
Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, ref GLfloat param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* param_ptr = ¶m)
|
|
{
|
|
Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint* param)
|
|
{
|
|
unsafe { Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param); }
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* param_ptr = param)
|
|
{
|
|
Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, out GLint param)
|
|
{
|
|
param = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* param_ptr = ¶m)
|
|
{
|
|
Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
|
|
param = *param_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat* param)
|
|
{
|
|
unsafe { Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param); }
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* param_ptr = param)
|
|
{
|
|
Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, out GLfloat param)
|
|
{
|
|
param = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* param_ptr = ¶m)
|
|
{
|
|
Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
|
|
param = *param_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 GenFragmentShaders(Int32 range)
|
|
{
|
|
return Delegates.glGenFragmentShadersATI((GLuint)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenFragmentShaders(GLuint range)
|
|
{
|
|
return Delegates.glGenFragmentShadersATI((GLuint)range);
|
|
}
|
|
|
|
public static
|
|
void BindFragmentShader(Int32 id)
|
|
{
|
|
Delegates.glBindFragmentShaderATI((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFragmentShader(GLuint id)
|
|
{
|
|
Delegates.glBindFragmentShaderATI((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void DeleteFragmentShader(Int32 id)
|
|
{
|
|
Delegates.glDeleteFragmentShaderATI((GLuint)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFragmentShader(GLuint id)
|
|
{
|
|
Delegates.glDeleteFragmentShaderATI((GLuint)id);
|
|
}
|
|
|
|
public static
|
|
void BeginFragmentShader()
|
|
{
|
|
Delegates.glBeginFragmentShaderATI();
|
|
}
|
|
|
|
public static
|
|
void EndFragmentShader()
|
|
{
|
|
Delegates.glEndFragmentShaderATI();
|
|
}
|
|
|
|
public static
|
|
void PassTexCoord(Int32 dst, Int32 coord, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glPassTexCoordATI((GLuint)dst, (GLuint)coord, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PassTexCoord(GLuint dst, GLuint coord, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glPassTexCoordATI((GLuint)dst, (GLuint)coord, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
public static
|
|
void SampleMap(Int32 dst, Int32 interp, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glSampleMapATI((GLuint)dst, (GLuint)interp, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SampleMap(GLuint dst, GLuint interp, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glSampleMapATI((GLuint)dst, (GLuint)interp, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp1(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
|
|
{
|
|
Delegates.glColorFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp1(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
|
|
{
|
|
Delegates.glColorFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp2(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
|
|
{
|
|
Delegates.glColorFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp2(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
|
|
{
|
|
Delegates.glColorFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp3(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
|
|
{
|
|
Delegates.glColorFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp3(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
|
|
{
|
|
Delegates.glColorFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp1(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp1(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp2(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp2(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp3(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp3(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetFragmentShaderConstant(Int32 dst, GLfloat* value)
|
|
{
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetFragmentShaderConstant(GLuint dst, GLfloat* value)
|
|
{
|
|
unsafe { Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value); }
|
|
}
|
|
|
|
public static
|
|
void SetFragmentShaderConstant(Int32 dst, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFragmentShaderConstant(GLuint dst, GLfloat[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetFragmentShaderConstant(Int32 dst, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFragmentShaderConstant(GLuint dst, ref GLfloat value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* value_ptr = &value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PNTrianglesi(GL.Enums.ATI_pn_triangles pname, GLint param)
|
|
{
|
|
Delegates.glPNTrianglesiATI((GL.Enums.ATI_pn_triangles)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void PNTrianglesf(GL.Enums.ATI_pn_triangles pname, GLfloat param)
|
|
{
|
|
Delegates.glPNTrianglesfATI((GL.Enums.ATI_pn_triangles)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 NewObjectBuffer(GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object usage)
|
|
{
|
|
unsafe { return Delegates.glNewObjectBufferATI((GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)usage); }
|
|
}
|
|
|
|
public static
|
|
Int32 NewObjectBuffer(GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object usage)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Int32 retval = Delegates.glNewObjectBufferATI((GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)usage);
|
|
return retval;
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsObjectBuffer(Int32 buffer)
|
|
{
|
|
return Delegates.glIsObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsObjectBuffer(GLuint buffer)
|
|
{
|
|
return Delegates.glIsObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UpdateObjectBuffer(Int32 buffer, Int32 offset, GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
{
|
|
Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UpdateObjectBuffer(GLuint buffer, GLuint offset, GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
unsafe { Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve); }
|
|
}
|
|
|
|
public static
|
|
void UpdateObjectBuffer(Int32 buffer, Int32 offset, GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UpdateObjectBuffer(GLuint buffer, GLuint offset, GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FreeObjectBuffer(Int32 buffer)
|
|
{
|
|
Delegates.glFreeObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FreeObjectBuffer(GLuint buffer)
|
|
{
|
|
Delegates.glFreeObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
public static
|
|
void ArrayObject(GL.Enums.EnableCap array, GLint size, GL.Enums.ATI_vertex_array_object type, GLsizei stride, Int32 buffer, Int32 offset)
|
|
{
|
|
Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (GLint)size, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ArrayObject(GL.Enums.EnableCap array, GLint size, GL.Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
|
|
{
|
|
Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (GLint)size, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VariantArrayObject(Int32 id, GL.Enums.ATI_vertex_array_object type, GLsizei stride, Int32 buffer, Int32 offset)
|
|
{
|
|
Delegates.glVariantArrayObjectATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VariantArrayObject(GLuint id, GL.Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
|
|
{
|
|
Delegates.glVariantArrayObjectATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1s(GL.Enums.ATI_vertex_streams stream, GLshort x)
|
|
{
|
|
Delegates.glVertexStream1sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1i(GL.Enums.ATI_vertex_streams stream, GLint x)
|
|
{
|
|
Delegates.glVertexStream1iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1f(GL.Enums.ATI_vertex_streams stream, GLfloat x)
|
|
{
|
|
Delegates.glVertexStream1fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1d(GL.Enums.ATI_vertex_streams stream, GLdouble x)
|
|
{
|
|
Delegates.glVertexStream1dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y)
|
|
{
|
|
Delegates.glVertexStream2sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y)
|
|
{
|
|
Delegates.glVertexStream2iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y)
|
|
{
|
|
Delegates.glVertexStream2fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y)
|
|
{
|
|
Delegates.glVertexStream2dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
Delegates.glVertexStream3sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y, (GLshort)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z)
|
|
{
|
|
Delegates.glVertexStream3iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y, (GLint)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
Delegates.glVertexStream3fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y, (GLfloat)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
Delegates.glVertexStream3dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y, (GLdouble)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
Delegates.glVertexStream4sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
Delegates.glVertexStream4iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
Delegates.glVertexStream4fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
Delegates.glVertexStream4dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3b(GL.Enums.ATI_vertex_streams stream, Byte nx, Byte ny, Byte nz)
|
|
{
|
|
Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3b(GL.Enums.ATI_vertex_streams stream, GLbyte nx, GLbyte ny, GLbyte nz)
|
|
{
|
|
Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, Byte* coords)
|
|
{
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, GLbyte* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, Byte[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, GLbyte[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, ref Byte coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, ref GLbyte coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLbyte* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3s(GL.Enums.ATI_vertex_streams stream, GLshort nx, GLshort ny, GLshort nz)
|
|
{
|
|
Delegates.glNormalStream3sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)nx, (GLshort)ny, (GLshort)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLshort* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3i(GL.Enums.ATI_vertex_streams stream, GLint nx, GLint ny, GLint nz)
|
|
{
|
|
Delegates.glNormalStream3iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)nx, (GLint)ny, (GLint)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3f(GL.Enums.ATI_vertex_streams stream, GLfloat nx, GLfloat ny, GLfloat nz)
|
|
{
|
|
Delegates.glNormalStream3fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3d(GL.Enums.ATI_vertex_streams stream, GLdouble nx, GLdouble ny, GLdouble nz)
|
|
{
|
|
Delegates.glNormalStream3dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)nx, (GLdouble)ny, (GLdouble)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLdouble* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClientActiveVertexStream(GL.Enums.ATI_vertex_streams stream)
|
|
{
|
|
Delegates.glClientActiveVertexStreamATI((GL.Enums.ATI_vertex_streams)stream);
|
|
}
|
|
|
|
public static
|
|
void VertexBlendEnvi(GL.Enums.ATI_vertex_streams pname, GLint param)
|
|
{
|
|
Delegates.glVertexBlendEnviATI((GL.Enums.ATI_vertex_streams)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void VertexBlendEnvf(GL.Enums.ATI_vertex_streams pname, GLfloat param)
|
|
{
|
|
Delegates.glVertexBlendEnvfATI((GL.Enums.ATI_vertex_streams)pname, (GLfloat)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ElementPointer(GL.Enums.ATI_element_array type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glElementPointerATI((GL.Enums.ATI_element_array)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ElementPointer(GL.Enums.ATI_element_array type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glElementPointerATI((GL.Enums.ATI_element_array)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawElementArray(GL.Enums.BeginMode mode, GLsizei count)
|
|
{
|
|
Delegates.glDrawElementArrayATI((GL.Enums.BeginMode)mode, (GLsizei)count);
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawBuffers(GLsizei n, GL.Enums.ATI_draw_buffers* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, GL.Enums.ATI_draw_buffers[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(GLsizei n, ref GL.Enums.ATI_draw_buffers bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
IntPtr MapObjectBuffer(Int32 buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
IntPtr retval = Delegates.glMapObjectBufferATI((GLuint)buffer);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
IntPtr MapObjectBuffer(GLuint buffer)
|
|
{
|
|
return Delegates.glMapObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
public static
|
|
void UnmapObjectBuffer(Int32 buffer)
|
|
{
|
|
Delegates.glUnmapObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UnmapObjectBuffer(GLuint buffer)
|
|
{
|
|
Delegates.glUnmapObjectBufferATI((GLuint)buffer);
|
|
}
|
|
|
|
public static
|
|
void StencilOpSeparate(GL.Enums.ATI_separate_stencil face, GL.Enums.StencilOp sfail, GL.Enums.StencilOp dpfail, GL.Enums.StencilOp dppass)
|
|
{
|
|
Delegates.glStencilOpSeparateATI((GL.Enums.ATI_separate_stencil)face, (GL.Enums.StencilOp)sfail, (GL.Enums.StencilOp)dpfail, (GL.Enums.StencilOp)dppass);
|
|
}
|
|
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
|
|
{
|
|
Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribArrayObject(Int32 index, GLint size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, GLsizei stride, Int32 buffer, Int32 offset)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glVertexAttribArrayObjectATI((GLuint)index, (GLint)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribArrayObject(GLuint index, GLint size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, GLsizei stride, GLuint buffer, GLuint offset)
|
|
{
|
|
Delegates.glVertexAttribArrayObjectATI((GLuint)index, (GLint)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat* @params)
|
|
{
|
|
@params = default(GLfloat*);
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLfloat @params)
|
|
{
|
|
@params = default(GLfloat);
|
|
unsafe
|
|
{
|
|
fixed (GLfloat* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint* @params)
|
|
{
|
|
@params = default(GLint*);
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLint @params)
|
|
{
|
|
@params = default(GLint);
|
|
unsafe
|
|
{
|
|
fixed (GLint* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class APPLE
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ElementPointer(GL.Enums.APPLE_element_array type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glElementPointerAPPLE((GL.Enums.APPLE_element_array)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ElementPointer(GL.Enums.APPLE_element_array type, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glElementPointerAPPLE((GL.Enums.APPLE_element_array)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawElementArray(GL.Enums.BeginMode mode, GLint first, GLsizei count)
|
|
{
|
|
Delegates.glDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint first, GLsizei count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint)first, (GLsizei)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, GLsizei* count, GLsizei primcount)
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, GLsizei[] count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, ref GLsizei count, GLsizei primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLint* first_ptr = &first)
|
|
fixed (GLsizei* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFences(GLsizei n, Int32* fences)
|
|
{
|
|
fences = default(Int32*);
|
|
{
|
|
Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFences(GLsizei n, GLuint* fences)
|
|
{
|
|
unsafe { Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences); }
|
|
}
|
|
|
|
public static
|
|
void GenFences(GLsizei n, Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFences(GLsizei n, GLuint[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFences(GLsizei n, out Int32 fences)
|
|
{
|
|
fences = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFences(GLsizei n, out GLuint fences)
|
|
{
|
|
fences = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFences(GLsizei n, Int32* fences)
|
|
{
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFences(GLsizei n, GLuint* fences)
|
|
{
|
|
unsafe { Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences); }
|
|
}
|
|
|
|
public static
|
|
void DeleteFences(GLsizei n, Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFences(GLsizei n, GLuint[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFences(GLsizei n, ref Int32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFences(GLsizei n, ref GLuint fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetFence(Int32 fence)
|
|
{
|
|
Delegates.glSetFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFence(GLuint fence)
|
|
{
|
|
Delegates.glSetFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
GLboolean IsFence(Int32 fence)
|
|
{
|
|
return Delegates.glIsFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsFence(GLuint fence)
|
|
{
|
|
return Delegates.glIsFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
GLboolean TestFence(Int32 fence)
|
|
{
|
|
return Delegates.glTestFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean TestFence(GLuint fence)
|
|
{
|
|
return Delegates.glTestFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
void FinishFence(Int32 fence)
|
|
{
|
|
Delegates.glFinishFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FinishFence(GLuint fence)
|
|
{
|
|
Delegates.glFinishFenceAPPLE((GLuint)fence);
|
|
}
|
|
|
|
public static
|
|
GLboolean TestObject(GL.Enums.APPLE_fence @object, Int32 name)
|
|
{
|
|
return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLuint)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean TestObject(GL.Enums.APPLE_fence @object, GLuint name)
|
|
{
|
|
return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLuint)name);
|
|
}
|
|
|
|
public static
|
|
void FinishObject(GL.Enums.APPLE_fence @object, GLint name)
|
|
{
|
|
Delegates.glFinishObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLint)name);
|
|
}
|
|
|
|
public static
|
|
void BindVertexArray(Int32 array)
|
|
{
|
|
Delegates.glBindVertexArrayAPPLE((GLuint)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindVertexArray(GLuint array)
|
|
{
|
|
Delegates.glBindVertexArrayAPPLE((GLuint)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteVertexArrays(GLsizei n, Int32* arrays)
|
|
{
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteVertexArrays(GLsizei n, GLuint* arrays)
|
|
{
|
|
unsafe { Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays); }
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexArrays(GLsizei n, Int32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexArrays(GLsizei n, GLuint[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexArrays(GLsizei n, ref Int32 arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexArrays(GLsizei n, ref GLuint arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenVertexArrays(GLsizei n, Int32* arrays)
|
|
{
|
|
arrays = default(Int32*);
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenVertexArrays(GLsizei n, GLuint* arrays)
|
|
{
|
|
unsafe { Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays); }
|
|
}
|
|
|
|
public static
|
|
void GenVertexArrays(GLsizei n, Int32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenVertexArrays(GLsizei n, GLuint[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GLuint* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenVertexArrays(GLsizei n, out Int32 arrays)
|
|
{
|
|
arrays = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
arrays = *arrays_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenVertexArrays(GLsizei n, out GLuint arrays)
|
|
{
|
|
arrays = default(GLuint);
|
|
unsafe
|
|
{
|
|
fixed (GLuint* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
|
|
arrays = *arrays_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GLboolean IsVertexArray(Int32 array)
|
|
{
|
|
return Delegates.glIsVertexArrayAPPLE((GLuint)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
GLboolean IsVertexArray(GLuint array)
|
|
{
|
|
return Delegates.glIsVertexArrayAPPLE((GLuint)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexArrayRange(GLsizei length, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexArrayRange(GLsizei length, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FlushVertexArrayRange(GLsizei length, void* pointer)
|
|
{
|
|
unsafe { Delegates.glFlushVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FlushVertexArrayRange(GLsizei length, object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glFlushVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexArrayParameteri(GL.Enums.APPLE_vertex_array_range pname, GLint param)
|
|
{
|
|
Delegates.glVertexArrayParameteriAPPLE((GL.Enums.APPLE_vertex_array_range)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void BufferParameteri(GL.Enums.APPLE_flush_buffer_range target, GL.Enums.APPLE_flush_buffer_range pname, GLint param)
|
|
{
|
|
Delegates.glBufferParameteriAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (GL.Enums.APPLE_flush_buffer_range)pname, (GLint)param);
|
|
}
|
|
|
|
public static
|
|
void FlushMappedBufferRange(GL.Enums.APPLE_flush_buffer_range target, GLintptr offset, GLsizeiptr size)
|
|
{
|
|
Delegates.glFlushMappedBufferRangeAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (GLintptr)offset, (GLsizeiptr)size);
|
|
}
|
|
|
|
}
|
|
|
|
public static class GREMEDY
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void StringMarker(GLsizei len, void* @string)
|
|
{
|
|
unsafe { Delegates.glStringMarkerGREMEDY((GLsizei)len, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void StringMarker(GLsizei len, object @string)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glStringMarkerGREMEDY((GLsizei)len, (void*)@string_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@string_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|