mirror of
https://github.com/Ryujinx/Opentk.git
synced 2024-12-25 04:35:29 +00:00
62269 lines
2.5 MiB
62269 lines
2.5 MiB
namespace OpenTK.OpenGL
|
|
{
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
public static partial class GL
|
|
{
|
|
static GL() { }
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NewList(UInt32 list, GL.Enums.ListMode mode)
|
|
{
|
|
Delegates.glNewList((UInt32)list, (GL.Enums.ListMode)mode);
|
|
}
|
|
|
|
public static
|
|
void NewList(Int32 list, GL.Enums.ListMode mode)
|
|
{
|
|
Delegates.glNewList((UInt32)list, (GL.Enums.ListMode)mode);
|
|
}
|
|
|
|
public static
|
|
void EndList()
|
|
{
|
|
Delegates.glEndList();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CallList(UInt32 list)
|
|
{
|
|
Delegates.glCallList((UInt32)list);
|
|
}
|
|
|
|
public static
|
|
void CallList(Int32 list)
|
|
{
|
|
Delegates.glCallList((UInt32)list);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CallLists(Int32 n, GL.Enums.ListNameType type, void* lists)
|
|
{
|
|
unsafe { Delegates.glCallLists((Int32)n, (GL.Enums.ListNameType)type, (void*)lists); }
|
|
}
|
|
|
|
public static
|
|
void CallLists(Int32 n, GL.Enums.ListNameType type, [In, Out] object lists)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle lists_ptr = System.Runtime.InteropServices.GCHandle.Alloc(lists, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glCallLists((Int32)n, (GL.Enums.ListNameType)type, (void*)lists_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
lists_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteLists(UInt32 list, Int32 range)
|
|
{
|
|
Delegates.glDeleteLists((UInt32)list, (Int32)range);
|
|
}
|
|
|
|
public static
|
|
void DeleteLists(Int32 list, Int32 range)
|
|
{
|
|
Delegates.glDeleteLists((UInt32)list, (Int32)range);
|
|
}
|
|
|
|
public static
|
|
Int32 GenLists(Int32 range)
|
|
{
|
|
return Delegates.glGenLists((Int32)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListBase(UInt32 @base)
|
|
{
|
|
Delegates.glListBase((UInt32)@base);
|
|
}
|
|
|
|
public static
|
|
void ListBase(Int32 @base)
|
|
{
|
|
Delegates.glListBase((UInt32)@base);
|
|
}
|
|
|
|
public static
|
|
void Begin(GL.Enums.BeginMode mode)
|
|
{
|
|
Delegates.glBegin((GL.Enums.BeginMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, Byte* bitmap)
|
|
{
|
|
unsafe { Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap); }
|
|
}
|
|
|
|
public static
|
|
void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, [In, Out] Byte[] bitmap)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* bitmap_ptr = bitmap)
|
|
{
|
|
Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, ref Byte bitmap)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* bitmap_ptr = &bitmap)
|
|
{
|
|
Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3(SByte red, SByte green, SByte blue)
|
|
{
|
|
Delegates.glColor3b((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
public static
|
|
void Color3(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glColor3b((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glColor3bv((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glColor3bv((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3(Double red, Double green, Double blue)
|
|
{
|
|
Delegates.glColor3d((Double)red, (Double)green, (Double)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glColor3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glColor3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3(Single red, Single green, Single blue)
|
|
{
|
|
Delegates.glColor3f((Single)red, (Single)green, (Single)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glColor3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glColor3i((Int32)red, (Int32)green, (Int32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glColor3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glColor3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glColor3s((Int16)red, (Int16)green, (Int16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glColor3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3(UInt32 red, UInt32 green, UInt32 blue)
|
|
{
|
|
Delegates.glColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(UInt32* v)
|
|
{
|
|
unsafe { Delegates.glColor3uiv((UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v([In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glColor3uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v(ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3(UInt16 red, UInt16 green, UInt16 blue)
|
|
{
|
|
Delegates.glColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3v(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glColor3usv((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3usv((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3v(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3usv((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4(SByte red, SByte green, SByte blue, SByte alpha)
|
|
{
|
|
Delegates.glColor4b((SByte)red, (SByte)green, (SByte)blue, (SByte)alpha);
|
|
}
|
|
|
|
public static
|
|
void Color4(Byte red, Byte green, Byte blue, Byte alpha)
|
|
{
|
|
Delegates.glColor4b((SByte)red, (SByte)green, (SByte)blue, (SByte)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glColor4bv((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glColor4bv((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glColor4bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glColor4bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4(Double red, Double green, Double blue, Double alpha)
|
|
{
|
|
Delegates.glColor4d((Double)red, (Double)green, (Double)blue, (Double)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(Double* v)
|
|
{
|
|
unsafe { Delegates.glColor4dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glColor4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4(Single red, Single green, Single blue, Single alpha)
|
|
{
|
|
Delegates.glColor4f((Single)red, (Single)green, (Single)blue, (Single)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(Single* v)
|
|
{
|
|
unsafe { Delegates.glColor4fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4(Int32 red, Int32 green, Int32 blue, Int32 alpha)
|
|
{
|
|
Delegates.glColor4i((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glColor4iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glColor4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4(Int16 red, Int16 green, Int16 blue, Int16 alpha)
|
|
{
|
|
Delegates.glColor4s((Int16)red, (Int16)green, (Int16)blue, (Int16)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glColor4sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Color4v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
|
|
{
|
|
Delegates.glColor4ui((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(UInt32* v)
|
|
{
|
|
unsafe { Delegates.glColor4uiv((UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v([In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glColor4uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v(ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
|
|
{
|
|
Delegates.glColor4us((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4v(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glColor4usv((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4usv((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4v(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4usv((UInt16*)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(Double c)
|
|
{
|
|
Delegates.glIndexd((Double)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexv(Double* c)
|
|
{
|
|
unsafe { Delegates.glIndexdv((Double*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexv([In, Out] Double[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* c_ptr = c)
|
|
{
|
|
Delegates.glIndexdv((Double*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexv(ref Double c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexdv((Double*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexf(Single c)
|
|
{
|
|
Delegates.glIndexf((Single)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexv(Single* c)
|
|
{
|
|
unsafe { Delegates.glIndexfv((Single*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexv([In, Out] Single[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glIndexfv((Single*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexv(ref Single c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexfv((Single*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexi(Int32 c)
|
|
{
|
|
Delegates.glIndexi((Int32)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexv(Int32* c)
|
|
{
|
|
unsafe { Delegates.glIndexiv((Int32*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexv([In, Out] Int32[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* c_ptr = c)
|
|
{
|
|
Delegates.glIndexiv((Int32*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexv(ref Int32 c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexiv((Int32*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexs(Int16 c)
|
|
{
|
|
Delegates.glIndexs((Int16)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexv(Int16* c)
|
|
{
|
|
unsafe { Delegates.glIndexsv((Int16*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexv([In, Out] Int16[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* c_ptr = c)
|
|
{
|
|
Delegates.glIndexsv((Int16*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexv(ref Int16 c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexsv((Int16*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3(SByte nx, SByte ny, SByte nz)
|
|
{
|
|
Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
|
|
}
|
|
|
|
public static
|
|
void Normal3(Byte nx, Byte ny, Byte nz)
|
|
{
|
|
Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glNormal3bv((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glNormal3bv((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3(Double nx, Double ny, Double nz)
|
|
{
|
|
Delegates.glNormal3d((Double)nx, (Double)ny, (Double)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glNormal3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3(Single nx, Single ny, Single nz)
|
|
{
|
|
Delegates.glNormal3f((Single)nx, (Single)ny, (Single)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glNormal3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3(Int32 nx, Int32 ny, Int32 nz)
|
|
{
|
|
Delegates.glNormal3i((Int32)nx, (Int32)ny, (Int32)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glNormal3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3(Int16 nx, Int16 ny, Int16 nz)
|
|
{
|
|
Delegates.glNormal3s((Int16)nx, (Int16)ny, (Int16)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glNormal3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Normal3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2(Double x, Double y)
|
|
{
|
|
Delegates.glRasterPos2d((Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2(Single x, Single y)
|
|
{
|
|
Delegates.glRasterPos2f((Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2(Int32 x, Int32 y)
|
|
{
|
|
Delegates.glRasterPos2i((Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glRasterPos2s((Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos2sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glRasterPos3d((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glRasterPos3f((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3(Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glRasterPos3i((Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glRasterPos3s((Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4(Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glRasterPos4d((Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4v(Double* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4(Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glRasterPos4f((Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4v(Single* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4(Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glRasterPos4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4(Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glRasterPos4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RasterPos4v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glRasterPos4sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glRasterPos4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RasterPos4v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glRasterPos4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectd(Double x1, Double y1, Double x2, Double y2)
|
|
{
|
|
Delegates.glRectd((Double)x1, (Double)y1, (Double)x2, (Double)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Double* v1, Double* v2)
|
|
{
|
|
unsafe { Delegates.glRectdv((Double*)v1, (Double*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Double* v1, [In, Out] Double[] v2)
|
|
{
|
|
fixed (Double* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Double* v1, ref Double v2)
|
|
{
|
|
fixed (Double* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv([In, Out] Double[] v1, Double* v2)
|
|
{
|
|
fixed (Double* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Double[] v1, [In, Out] Double[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v1_ptr = v1)
|
|
fixed (Double* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Double[] v1, ref Double v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v1_ptr = v1)
|
|
fixed (Double* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(ref Double v1, Double* v2)
|
|
{
|
|
fixed (Double* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Double v1, [In, Out] Double[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v1_ptr = &v1)
|
|
fixed (Double* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Double v1, ref Double v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v1_ptr = &v1)
|
|
fixed (Double* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectf(Single x1, Single y1, Single x2, Single y2)
|
|
{
|
|
Delegates.glRectf((Single)x1, (Single)y1, (Single)x2, (Single)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Single* v1, Single* v2)
|
|
{
|
|
unsafe { Delegates.glRectfv((Single*)v1, (Single*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Single* v1, [In, Out] Single[] v2)
|
|
{
|
|
fixed (Single* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Single* v1, ref Single v2)
|
|
{
|
|
fixed (Single* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv([In, Out] Single[] v1, Single* v2)
|
|
{
|
|
fixed (Single* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Single[] v1, [In, Out] Single[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v1_ptr = v1)
|
|
fixed (Single* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Single[] v1, ref Single v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v1_ptr = v1)
|
|
fixed (Single* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(ref Single v1, Single* v2)
|
|
{
|
|
fixed (Single* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Single v1, [In, Out] Single[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v1_ptr = &v1)
|
|
fixed (Single* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Single v1, ref Single v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v1_ptr = &v1)
|
|
fixed (Single* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Recti(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
|
|
{
|
|
Delegates.glRecti((Int32)x1, (Int32)y1, (Int32)x2, (Int32)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int32* v1, Int32* v2)
|
|
{
|
|
unsafe { Delegates.glRectiv((Int32*)v1, (Int32*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int32* v1, [In, Out] Int32[] v2)
|
|
{
|
|
fixed (Int32* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int32* v1, ref Int32 v2)
|
|
{
|
|
fixed (Int32* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv([In, Out] Int32[] v1, Int32* v2)
|
|
{
|
|
fixed (Int32* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Int32[] v1, [In, Out] Int32[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v1_ptr = v1)
|
|
fixed (Int32* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Int32[] v1, ref Int32 v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v1_ptr = v1)
|
|
fixed (Int32* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(ref Int32 v1, Int32* v2)
|
|
{
|
|
fixed (Int32* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Int32 v1, [In, Out] Int32[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v1_ptr = &v1)
|
|
fixed (Int32* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Int32 v1, ref Int32 v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v1_ptr = &v1)
|
|
fixed (Int32* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rects(Int16 x1, Int16 y1, Int16 x2, Int16 y2)
|
|
{
|
|
Delegates.glRects((Int16)x1, (Int16)y1, (Int16)x2, (Int16)y2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int16* v1, Int16* v2)
|
|
{
|
|
unsafe { Delegates.glRectsv((Int16*)v1, (Int16*)v2); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int16* v1, [In, Out] Int16[] v2)
|
|
{
|
|
fixed (Int16* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(Int16* v1, ref Int16 v2)
|
|
{
|
|
fixed (Int16* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv([In, Out] Int16[] v1, Int16* v2)
|
|
{
|
|
fixed (Int16* v1_ptr = v1)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Int16[] v1, [In, Out] Int16[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v1_ptr = v1)
|
|
fixed (Int16* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv([In, Out] Int16[] v1, ref Int16 v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v1_ptr = v1)
|
|
fixed (Int16* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Rectv(ref Int16 v1, Int16* v2)
|
|
{
|
|
fixed (Int16* v1_ptr = &v1)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Int16 v1, [In, Out] Int16[] v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v1_ptr = &v1)
|
|
fixed (Int16* v2_ptr = v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Rectv(ref Int16 v1, ref Int16 v2)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v1_ptr = &v1)
|
|
fixed (Int16* v2_ptr = &v2)
|
|
{
|
|
Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1(Double s)
|
|
{
|
|
Delegates.glTexCoord1d((Double)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1v(Double* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1(Single s)
|
|
{
|
|
Delegates.glTexCoord1f((Single)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1v(Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1(Int32 s)
|
|
{
|
|
Delegates.glTexCoord1i((Int32)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1(Int16 s)
|
|
{
|
|
Delegates.glTexCoord1s((Int16)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2(Double s, Double t)
|
|
{
|
|
Delegates.glTexCoord2d((Double)s, (Double)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2(Single s, Single t)
|
|
{
|
|
Delegates.glTexCoord2f((Single)s, (Single)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2(Int32 s, Int32 t)
|
|
{
|
|
Delegates.glTexCoord2i((Int32)s, (Int32)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2(Int16 s, Int16 t)
|
|
{
|
|
Delegates.glTexCoord2s((Int16)s, (Int16)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3(Double s, Double t, Double r)
|
|
{
|
|
Delegates.glTexCoord3d((Double)s, (Double)t, (Double)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3(Single s, Single t, Single r)
|
|
{
|
|
Delegates.glTexCoord3f((Single)s, (Single)t, (Single)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3(Int32 s, Int32 t, Int32 r)
|
|
{
|
|
Delegates.glTexCoord3i((Int32)s, (Int32)t, (Int32)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3(Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glTexCoord3s((Int16)s, (Int16)t, (Int16)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4(Double s, Double t, Double r, Double q)
|
|
{
|
|
Delegates.glTexCoord4d((Double)s, (Double)t, (Double)r, (Double)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4v(Double* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4(Single s, Single t, Single r, Single q)
|
|
{
|
|
Delegates.glTexCoord4f((Single)s, (Single)t, (Single)r, (Single)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4v(Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4(Int32 s, Int32 t, Int32 r, Int32 q)
|
|
{
|
|
Delegates.glTexCoord4i((Int32)s, (Int32)t, (Int32)r, (Int32)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4(Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glTexCoord4s((Int16)s, (Int16)t, (Int16)r, (Int16)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2(Double x, Double y)
|
|
{
|
|
Delegates.glVertex2d((Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glVertex2dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2(Single x, Single y)
|
|
{
|
|
Delegates.glVertex2f((Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glVertex2fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2(Int32 x, Int32 y)
|
|
{
|
|
Delegates.glVertex2i((Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertex2iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertex2s((Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertex2sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertex3d((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glVertex3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertex3f((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glVertex3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3(Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glVertex3i((Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertex3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertex3s((Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertex3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4(Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertex4d((Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4v(Double* v)
|
|
{
|
|
unsafe { Delegates.glVertex4dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4(Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertex4f((Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4v(Single* v)
|
|
{
|
|
unsafe { Delegates.glVertex4fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4(Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glVertex4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertex4iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4(Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertex4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertex4sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Vertex4v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ClipPlane(GL.Enums.ClipPlaneName plane, Double* equation)
|
|
{
|
|
unsafe { Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)equation); }
|
|
}
|
|
|
|
public static
|
|
void ClipPlane(GL.Enums.ClipPlaneName plane, [In, Out] Double[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = equation)
|
|
{
|
|
Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClipPlane(GL.Enums.ClipPlaneName plane, ref Double equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = &equation)
|
|
{
|
|
Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)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, Single param)
|
|
{
|
|
Delegates.glFogf((GL.Enums.FogParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Fogv(GL.Enums.FogParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glFogfv((GL.Enums.FogParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Fogv(GL.Enums.FogParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glFogfv((GL.Enums.FogParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogv(GL.Enums.FogParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFogfv((GL.Enums.FogParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogi(GL.Enums.FogParameter pname, Int32 param)
|
|
{
|
|
Delegates.glFogi((GL.Enums.FogParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Fogv(GL.Enums.FogParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glFogiv((GL.Enums.FogParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Fogv(GL.Enums.FogParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glFogiv((GL.Enums.FogParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Fogv(GL.Enums.FogParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFogiv((GL.Enums.FogParameter)pname, (Int32*)@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, Single param)
|
|
{
|
|
Delegates.glLightf((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lighti(GL.Enums.LightName light, GL.Enums.LightParameter pname, Int32 param)
|
|
{
|
|
Delegates.glLighti((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Lightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModelf(GL.Enums.LightModelParameter pname, Single param)
|
|
{
|
|
Delegates.glLightModelf((GL.Enums.LightModelParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LightModelv(GL.Enums.LightModelParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void LightModelv(GL.Enums.LightModelParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModelv(GL.Enums.LightModelParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModeli(GL.Enums.LightModelParameter pname, Int32 param)
|
|
{
|
|
Delegates.glLightModeli((GL.Enums.LightModelParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LightModelv(GL.Enums.LightModelParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void LightModelv(GL.Enums.LightModelParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightModelv(GL.Enums.LightModelParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LineStipple(Int32 factor, UInt16 pattern)
|
|
{
|
|
Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
|
|
}
|
|
|
|
public static
|
|
void LineStipple(Int32 factor, Int16 pattern)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LineWidth(Single width)
|
|
{
|
|
Delegates.glLineWidth((Single)width);
|
|
}
|
|
|
|
public static
|
|
void Materialf(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Single param)
|
|
{
|
|
Delegates.glMaterialf((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materiali(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Int32 param)
|
|
{
|
|
Delegates.glMateriali((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Materialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointSize(Single size)
|
|
{
|
|
Delegates.glPointSize((Single)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(Byte* mask)
|
|
{
|
|
unsafe { Delegates.glPolygonStipple((Byte*)mask); }
|
|
}
|
|
|
|
public static
|
|
void PolygonStipple([In, Out] Byte[] mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* mask_ptr = mask)
|
|
{
|
|
Delegates.glPolygonStipple((Byte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PolygonStipple(ref Byte mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* mask_ptr = &mask)
|
|
{
|
|
Delegates.glPolygonStipple((Byte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Scissor(Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glScissor((Int32)x, (Int32)y, (Int32)width, (Int32)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, Single param)
|
|
{
|
|
Delegates.glTexParameterf((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameteri(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32 param)
|
|
{
|
|
Delegates.glTexParameteri((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage1D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)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, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage2D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage2D(GL.Enums.TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)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, Single param)
|
|
{
|
|
Delegates.glTexEnvf((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvi(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, Int32 param)
|
|
{
|
|
Delegates.glTexEnvi((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGend(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Double param)
|
|
{
|
|
Delegates.glTexGend((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Double* @params)
|
|
{
|
|
unsafe { Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref Double @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenf(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Single param)
|
|
{
|
|
Delegates.glTexGenf((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGeni(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Int32 param)
|
|
{
|
|
Delegates.glTexGeni((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FeedbackBuffer(Int32 size, GL.Enums.FeedbackType type, [Out] Single* buffer)
|
|
{
|
|
unsafe { Delegates.glFeedbackBuffer((Int32)size, (GL.Enums.FeedbackType)type, (Single*)buffer); }
|
|
}
|
|
|
|
public static
|
|
void FeedbackBuffer(Int32 size, GL.Enums.FeedbackType type, [In, Out] Single[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glFeedbackBuffer((Int32)size, (GL.Enums.FeedbackType)type, (Single*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FeedbackBuffer(Int32 size, GL.Enums.FeedbackType type, [Out] out Single buffer)
|
|
{
|
|
buffer = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glFeedbackBuffer((Int32)size, (GL.Enums.FeedbackType)type, (Single*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SelectBuffer(Int32 size, [Out] UInt32* buffer)
|
|
{
|
|
unsafe { Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SelectBuffer(Int32 size, [Out] Int32* buffer)
|
|
{
|
|
buffer = default(Int32*);
|
|
{
|
|
Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SelectBuffer(Int32 size, [In, Out] UInt32[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SelectBuffer(Int32 size, [In, Out] Int32[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SelectBuffer(Int32 size, [Out] out UInt32 buffer)
|
|
{
|
|
buffer = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SelectBuffer(Int32 size, [Out] out Int32 buffer)
|
|
{
|
|
buffer = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 RenderMode(GL.Enums.RenderingMode mode)
|
|
{
|
|
return Delegates.glRenderMode((GL.Enums.RenderingMode)mode);
|
|
}
|
|
|
|
public static
|
|
void InitNames()
|
|
{
|
|
Delegates.glInitNames();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadName(UInt32 name)
|
|
{
|
|
Delegates.glLoadName((UInt32)name);
|
|
}
|
|
|
|
public static
|
|
void LoadName(Int32 name)
|
|
{
|
|
Delegates.glLoadName((UInt32)name);
|
|
}
|
|
|
|
public static
|
|
void PassThrough(Single token)
|
|
{
|
|
Delegates.glPassThrough((Single)token);
|
|
}
|
|
|
|
public static
|
|
void PopName()
|
|
{
|
|
Delegates.glPopName();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PushName(UInt32 name)
|
|
{
|
|
Delegates.glPushName((UInt32)name);
|
|
}
|
|
|
|
public static
|
|
void PushName(Int32 name)
|
|
{
|
|
Delegates.glPushName((UInt32)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(Single red, Single green, Single blue, Single alpha)
|
|
{
|
|
Delegates.glClearAccum((Single)red, (Single)green, (Single)blue, (Single)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearIndex(Single c)
|
|
{
|
|
Delegates.glClearIndex((Single)c);
|
|
}
|
|
|
|
public static
|
|
void ClearColor(Single red, Single green, Single blue, Single alpha)
|
|
{
|
|
Delegates.glClearColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearStencil(Int32 s)
|
|
{
|
|
Delegates.glClearStencil((Int32)s);
|
|
}
|
|
|
|
public static
|
|
void ClearDepth(Double depth)
|
|
{
|
|
Delegates.glClearDepth((Double)depth);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilMask(UInt32 mask)
|
|
{
|
|
Delegates.glStencilMask((UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilMask(Int32 mask)
|
|
{
|
|
Delegates.glStencilMask((UInt32)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);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void IndexMask(UInt32 mask)
|
|
{
|
|
Delegates.glIndexMask((UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void IndexMask(Int32 mask)
|
|
{
|
|
Delegates.glIndexMask((UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void Accum(GL.Enums.AccumOp op, Single value)
|
|
{
|
|
Delegates.glAccum((GL.Enums.AccumOp)op, (Single)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 Map1(GL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, Double* points)
|
|
{
|
|
unsafe { Delegates.glMap1d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map1(GL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, [In, Out] Double[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = points)
|
|
{
|
|
Delegates.glMap1d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map1(GL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, ref Double points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = &points)
|
|
{
|
|
Delegates.glMap1d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map1(GL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, Single* points)
|
|
{
|
|
unsafe { Delegates.glMap1f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map1(GL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glMap1f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map1(GL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glMap1f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map2(GL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double* points)
|
|
{
|
|
unsafe { Delegates.glMap2d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map2(GL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, [In, Out] Double[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = points)
|
|
{
|
|
Delegates.glMap2d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map2(GL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, ref Double points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = &points)
|
|
{
|
|
Delegates.glMap2d((GL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Map2(GL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single* points)
|
|
{
|
|
unsafe { Delegates.glMap2f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void Map2(GL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glMap2f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Map2(GL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glMap2f((GL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapGrid1(Int32 un, Double u1, Double u2)
|
|
{
|
|
Delegates.glMapGrid1d((Int32)un, (Double)u1, (Double)u2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid1(Int32 un, Single u1, Single u2)
|
|
{
|
|
Delegates.glMapGrid1f((Int32)un, (Single)u1, (Single)u2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid2(Int32 un, Double u1, Double u2, Int32 vn, Double v1, Double v2)
|
|
{
|
|
Delegates.glMapGrid2d((Int32)un, (Double)u1, (Double)u2, (Int32)vn, (Double)v1, (Double)v2);
|
|
}
|
|
|
|
public static
|
|
void MapGrid2(Int32 un, Single u1, Single u2, Int32 vn, Single v1, Single v2)
|
|
{
|
|
Delegates.glMapGrid2f((Int32)un, (Single)u1, (Single)u2, (Int32)vn, (Single)v1, (Single)v2);
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1(Double u)
|
|
{
|
|
Delegates.glEvalCoord1d((Double)u);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord1v(Double* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord1dv((Double*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1v([In, Out] Double[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord1dv((Double*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1v(ref Double u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord1dv((Double*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1(Single u)
|
|
{
|
|
Delegates.glEvalCoord1f((Single)u);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord1v(Single* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord1fv((Single*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1v([In, Out] Single[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord1fv((Single*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord1v(ref Single u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord1fv((Single*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2(Double u, Double v)
|
|
{
|
|
Delegates.glEvalCoord2d((Double)u, (Double)v);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord2v(Double* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord2dv((Double*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2v([In, Out] Double[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord2dv((Double*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2v(ref Double u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord2dv((Double*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2(Single u, Single v)
|
|
{
|
|
Delegates.glEvalCoord2f((Single)u, (Single)v);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EvalCoord2v(Single* u)
|
|
{
|
|
unsafe { Delegates.glEvalCoord2fv((Single*)u); }
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2v([In, Out] Single[] u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* u_ptr = u)
|
|
{
|
|
Delegates.glEvalCoord2fv((Single*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalCoord2v(ref Single u)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* u_ptr = &u)
|
|
{
|
|
Delegates.glEvalCoord2fv((Single*)u_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalMesh1(GL.Enums.MeshMode1 mode, Int32 i1, Int32 i2)
|
|
{
|
|
Delegates.glEvalMesh1((GL.Enums.MeshMode1)mode, (Int32)i1, (Int32)i2);
|
|
}
|
|
|
|
public static
|
|
void EvalPoint1(Int32 i)
|
|
{
|
|
Delegates.glEvalPoint1((Int32)i);
|
|
}
|
|
|
|
public static
|
|
void EvalMesh2(GL.Enums.MeshMode2 mode, Int32 i1, Int32 i2, Int32 j1, Int32 j2)
|
|
{
|
|
Delegates.glEvalMesh2((GL.Enums.MeshMode2)mode, (Int32)i1, (Int32)i2, (Int32)j1, (Int32)j2);
|
|
}
|
|
|
|
public static
|
|
void EvalPoint2(Int32 i, Int32 j)
|
|
{
|
|
Delegates.glEvalPoint2((Int32)i, (Int32)j);
|
|
}
|
|
|
|
public static
|
|
void AlphaFunc(GL.Enums.AlphaFunction func, Single @ref)
|
|
{
|
|
Delegates.glAlphaFunc((GL.Enums.AlphaFunction)func, (Single)@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);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFunc(GL.Enums.StencilFunction func, Int32 @ref, UInt32 mask)
|
|
{
|
|
Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (Int32)@ref, (UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilFunc(GL.Enums.StencilFunction func, Int32 @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (Int32)@ref, (UInt32)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(Single xfactor, Single yfactor)
|
|
{
|
|
Delegates.glPixelZoom((Single)xfactor, (Single)yfactor);
|
|
}
|
|
|
|
public static
|
|
void PixelTransferf(GL.Enums.PixelTransferParameter pname, Single param)
|
|
{
|
|
Delegates.glPixelTransferf((GL.Enums.PixelTransferParameter)pname, (Single)param);
|
|
}
|
|
|
|
public static
|
|
void PixelTransferi(GL.Enums.PixelTransferParameter pname, Int32 param)
|
|
{
|
|
Delegates.glPixelTransferi((GL.Enums.PixelTransferParameter)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void PixelStoref(GL.Enums.PixelStoreParameter pname, Single param)
|
|
{
|
|
Delegates.glPixelStoref((GL.Enums.PixelStoreParameter)pname, (Single)param);
|
|
}
|
|
|
|
public static
|
|
void PixelStorei(GL.Enums.PixelStoreParameter pname, Int32 param)
|
|
{
|
|
Delegates.glPixelStorei((GL.Enums.PixelStoreParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, Single* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values); }
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, [In, Out] Single[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, ref Single values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, UInt32* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, Int32* values)
|
|
{
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, [In, Out] UInt32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, [In, Out] Int32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, ref UInt32 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, ref Int32 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, UInt16* values)
|
|
{
|
|
unsafe { Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, Int16* values)
|
|
{
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, [In, Out] UInt16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, [In, Out] Int16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, ref UInt16 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelMapv(GL.Enums.PixelMap map, Int32 mapsize, ref Int16 values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = &values)
|
|
{
|
|
Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReadBuffer(GL.Enums.ReadBufferMode mode)
|
|
{
|
|
Delegates.glReadBuffer((GL.Enums.ReadBufferMode)mode);
|
|
}
|
|
|
|
public static
|
|
void CopyPixels(Int32 x, Int32 y, Int32 width, Int32 height, GL.Enums.PixelCopyType type)
|
|
{
|
|
Delegates.glCopyPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (GL.Enums.PixelCopyType)type);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* pixels)
|
|
{
|
|
unsafe { Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void ReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)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(Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glDrawPixels((Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void DrawPixels(Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object pixels)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glDrawPixels((Int32)width, (Int32)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, [Out] 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, [Out] Double* equation)
|
|
{
|
|
unsafe { Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)equation); }
|
|
}
|
|
|
|
public static
|
|
void GetClipPlane(GL.Enums.ClipPlaneName plane, [In, Out] Double[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = equation)
|
|
{
|
|
Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetClipPlane(GL.Enums.ClipPlaneName plane, [Out] out Double equation)
|
|
{
|
|
equation = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = &equation)
|
|
{
|
|
Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
|
|
equation = *equation_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetDoublev(GL.Enums.GetPName pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetDoublev((GL.Enums.GetPName)pname, (Double*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetDoublev(GL.Enums.GetPName pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetDoublev((GL.Enums.GetPName)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetDoublev(GL.Enums.GetPName pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetDoublev((GL.Enums.GetPName)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GL.Enums.All GetError()
|
|
{
|
|
return Delegates.glGetError();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFloatv(GL.Enums.GetPName pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetFloatv((GL.Enums.GetPName)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFloatv(GL.Enums.GetPName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFloatv((GL.Enums.GetPName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFloatv(GL.Enums.GetPName pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFloatv((GL.Enums.GetPName)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerv(GL.Enums.GetPName pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetIntegerv(GL.Enums.GetPName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetIntegerv(GL.Enums.GetPName pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLightv(GL.Enums.LightName light, GL.Enums.LightParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] Double* v)
|
|
{
|
|
unsafe { Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] out Double v)
|
|
{
|
|
v = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Double*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] Single* v)
|
|
{
|
|
unsafe { Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] out Single v)
|
|
{
|
|
v = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Single*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] Int32* v)
|
|
{
|
|
unsafe { Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, [Out] out Int32 v)
|
|
{
|
|
v = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (Int32*)v_ptr);
|
|
v = *v_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapv(GL.Enums.PixelMap map, [Out] Single* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (Single*)values); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [In, Out] Single[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (Single*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [Out] out Single values)
|
|
{
|
|
values = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (Single*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapv(GL.Enums.PixelMap map, [Out] UInt32* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapv(GL.Enums.PixelMap map, [Out] Int32* values)
|
|
{
|
|
values = default(Int32*);
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [In, Out] UInt32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [In, Out] Int32[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [Out] out UInt32 values)
|
|
{
|
|
values = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [Out] out Int32 values)
|
|
{
|
|
values = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (UInt32*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapv(GL.Enums.PixelMap map, [Out] UInt16* values)
|
|
{
|
|
unsafe { Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelMapv(GL.Enums.PixelMap map, [Out] Int16* values)
|
|
{
|
|
values = default(Int16*);
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [In, Out] UInt16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [In, Out] Int16[] values)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [Out] out UInt16 values)
|
|
{
|
|
values = default(UInt16);
|
|
unsafe
|
|
{
|
|
fixed (UInt16* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelMapv(GL.Enums.PixelMap map, [Out] out Int16 values)
|
|
{
|
|
values = default(Int16);
|
|
unsafe
|
|
{
|
|
fixed (Int16* values_ptr = &values)
|
|
{
|
|
Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (UInt16*)values_ptr);
|
|
values = *values_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPolygonStipple([Out] Byte* mask)
|
|
{
|
|
unsafe { Delegates.glGetPolygonStipple((Byte*)mask); }
|
|
}
|
|
|
|
public static
|
|
void GetPolygonStipple([In, Out] Byte[] mask)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* mask_ptr = mask)
|
|
{
|
|
Delegates.glGetPolygonStipple((Byte*)mask_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPolygonStipple([Out] out Byte mask)
|
|
{
|
|
mask = default(Byte);
|
|
unsafe
|
|
{
|
|
fixed (Byte* mask_ptr = &mask)
|
|
{
|
|
Delegates.glGetPolygonStipple((Byte*)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 GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexEnvv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexGenv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexImage(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* pixels)
|
|
{
|
|
unsafe { Delegates.glGetTexImage((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void GetTexImage(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexLevelParameterv(GL.Enums.TextureTarget target, Int32 level, GL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Boolean IsEnabled(GL.Enums.EnableCap cap)
|
|
{
|
|
return Delegates.glIsEnabled((GL.Enums.EnableCap)cap);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsList(UInt32 list)
|
|
{
|
|
return Delegates.glIsList((UInt32)list);
|
|
}
|
|
|
|
public static
|
|
Boolean IsList(Int32 list)
|
|
{
|
|
return Delegates.glIsList((UInt32)list);
|
|
}
|
|
|
|
public static
|
|
void DepthRange(Double near, Double far)
|
|
{
|
|
Delegates.glDepthRange((Double)near, (Double)far);
|
|
}
|
|
|
|
public static
|
|
void Frustum(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
|
|
{
|
|
Delegates.glFrustum((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
|
|
}
|
|
|
|
public static
|
|
void LoadIdentity()
|
|
{
|
|
Delegates.glLoadIdentity();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadMatrixf(Single* m)
|
|
{
|
|
unsafe { Delegates.glLoadMatrixf((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixf([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glLoadMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixf(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadMatrixd(Double* m)
|
|
{
|
|
unsafe { Delegates.glLoadMatrixd((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixd([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glLoadMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadMatrixd(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixMode(GL.Enums.MatrixMode mode)
|
|
{
|
|
Delegates.glMatrixMode((GL.Enums.MatrixMode)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultMatrixf(Single* m)
|
|
{
|
|
unsafe { Delegates.glMultMatrixf((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultMatrixf([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glMultMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultMatrixf(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glMultMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultMatrixd(Double* m)
|
|
{
|
|
unsafe { Delegates.glMultMatrixd((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultMatrixd([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glMultMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultMatrixd(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glMultMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Ortho(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
|
|
{
|
|
Delegates.glOrtho((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
|
|
}
|
|
|
|
public static
|
|
void PopMatrix()
|
|
{
|
|
Delegates.glPopMatrix();
|
|
}
|
|
|
|
public static
|
|
void PushMatrix()
|
|
{
|
|
Delegates.glPushMatrix();
|
|
}
|
|
|
|
public static
|
|
void Rotated(Double angle, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glRotated((Double)angle, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void Rotatef(Single angle, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glRotatef((Single)angle, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void Scaled(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glScaled((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void Scalef(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glScalef((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void Translated(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glTranslated((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void Translatef(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTranslatef((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void Viewport(Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glViewport((Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
public static
|
|
void ArrayElement(Int32 i)
|
|
{
|
|
Delegates.glArrayElement((Int32)i);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointer(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointer((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointer(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointer((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)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, Int32 first, Int32 count)
|
|
{
|
|
Delegates.glDrawArrays((GL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawElements(GL.Enums.BeginMode mode, Int32 count, GL.Enums.All type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawElements((GL.Enums.BeginMode)mode, (Int32)count, (GL.Enums.All)type, (void*)indices); }
|
|
}
|
|
|
|
public static
|
|
void DrawElements(GL.Enums.BeginMode mode, Int32 count, GL.Enums.All type, [In, Out] 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, (Int32)count, (GL.Enums.All)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointer(Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointer((Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void EdgeFlagPointer(Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glEdgeFlagPointer((Int32)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, [Out] void* @params)
|
|
{
|
|
unsafe { Delegates.glGetPointerv((GL.Enums.GetPointervPName)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPointerv(GL.Enums.GetPointervPName pname, [In, Out] 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, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glIndexPointer((GL.Enums.IndexPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointer(GL.Enums.IndexPointerType type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glInterleavedArrays((GL.Enums.InterleavedArrayFormat)format, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointer(GL.Enums.NormalPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glNormalPointer((GL.Enums.NormalPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointer(GL.Enums.NormalPointerType type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointer(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointer((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointer(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointer((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointer(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointer((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointer(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointer((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PolygonOffset(Single factor, Single units)
|
|
{
|
|
Delegates.glPolygonOffset((Single)factor, (Single)units);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage1D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
|
|
{
|
|
Delegates.glCopyTexImage1D((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage2D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
|
|
{
|
|
Delegates.glCopyTexImage2D((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyTexSubImage1D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage2D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyTexSubImage2D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage1D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)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, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage2D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage2D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, UInt32* textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, Int32* textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, [In, Out] UInt32[] textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, [In, Out] Int32[] textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, ref UInt32 textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResident(Int32 n, ref Int32 textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, UInt32 texture)
|
|
{
|
|
Delegates.glBindTexture((GL.Enums.TextureTarget)target, (UInt32)texture);
|
|
}
|
|
|
|
public static
|
|
void BindTexture(GL.Enums.TextureTarget target, Int32 texture)
|
|
{
|
|
Delegates.glBindTexture((GL.Enums.TextureTarget)target, (UInt32)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(Int32 n, UInt32* textures)
|
|
{
|
|
unsafe { Delegates.glDeleteTextures((Int32)n, (UInt32*)textures); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTextures(Int32 n, Int32* textures)
|
|
{
|
|
{
|
|
Delegates.glDeleteTextures((Int32)n, (UInt32*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(Int32 n, [In, Out] UInt32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(Int32 n, [In, Out] Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTextures(Int32 n, ref UInt32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTextures(Int32 n, ref Int32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(Int32 n, [Out] UInt32* textures)
|
|
{
|
|
unsafe { Delegates.glGenTextures((Int32)n, (UInt32*)textures); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTextures(Int32 n, [Out] Int32* textures)
|
|
{
|
|
textures = default(Int32*);
|
|
{
|
|
Delegates.glGenTextures((Int32)n, (UInt32*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(Int32 n, [In, Out] UInt32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTextures(Int32 n, [In, Out] Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTextures(Int32 n, [Out] out UInt32 textures)
|
|
{
|
|
textures = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTextures(Int32 n, [Out] out Int32 textures)
|
|
{
|
|
textures = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsTexture(UInt32 texture)
|
|
{
|
|
return Delegates.glIsTexture((UInt32)texture);
|
|
}
|
|
|
|
public static
|
|
Boolean IsTexture(Int32 texture)
|
|
{
|
|
return Delegates.glIsTexture((UInt32)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, UInt32* textures, Single* priorities)
|
|
{
|
|
unsafe { Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, Int32* textures, Single* priorities)
|
|
{
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, UInt32* textures, [In, Out] Single[] priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, Int32* textures, [In, Out] Single[] priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, UInt32* textures, ref Single priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, Int32* textures, ref Single priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, [In, Out] UInt32[] textures, Single* priorities)
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, [In, Out] Int32[] textures, Single* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(Int32 n, [In, Out] UInt32[] textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(Int32 n, [In, Out] Int32[] textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(Int32 n, [In, Out] UInt32[] textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(Int32 n, [In, Out] Int32[] textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, ref UInt32 textures, Single* priorities)
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTextures(Int32 n, ref Int32 textures, Single* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(Int32 n, ref UInt32 textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(Int32 n, ref Int32 textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTextures(Int32 n, ref UInt32 textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTextures(Int32 n, ref Int32 textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Index(Byte c)
|
|
{
|
|
Delegates.glIndexub((Byte)c);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Indexv(Byte* c)
|
|
{
|
|
unsafe { Delegates.glIndexubv((Byte*)c); }
|
|
}
|
|
|
|
public static
|
|
void Indexv([In, Out] Byte[] c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glIndexubv((Byte*)c_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Indexv(ref Byte c)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glIndexubv((Byte*)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(Single red, Single green, Single blue, Single alpha)
|
|
{
|
|
Delegates.glBlendColor((Single)red, (Single)green, (Single)blue, (Single)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, UInt32 start, UInt32 end, Int32 count, GL.Enums.VERSION_1_2 type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.VERSION_1_2)type, (void*)indices); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, GL.Enums.VERSION_1_2 type, void* indices)
|
|
{
|
|
{
|
|
Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.VERSION_1_2)type, (void*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, GL.Enums.VERSION_1_2 type, [In, Out] 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, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.VERSION_1_2)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, GL.Enums.VERSION_1_2 type, [In, Out] 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, (UInt32)start, (UInt32)end, (Int32)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, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)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, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] 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, [In, Out] 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 GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorSubTable(GL.Enums.VERSION_1_2 target, Int32 start, Int32 count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
|
|
{
|
|
unsafe { Delegates.glColorSubTable((GL.Enums.VERSION_1_2)target, (Int32)start, (Int32)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void ColorSubTable(GL.Enums.VERSION_1_2 target, Int32 start, Int32 count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)start, (Int32)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, Int32 start, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyColorSubTable((GL.Enums.VERSION_1_2)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)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, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)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, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)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, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (Int32)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, Single @params)
|
|
{
|
|
Delegates.glConvolutionParameterf((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteri(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, Int32 @params)
|
|
{
|
|
Delegates.glConvolutionParameteri((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] 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, [In, Out] 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 GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@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, [Out] void* row, [Out] void* column, [Out] 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, [Out] void* row, [Out] void* column, [In, Out] 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, [Out] void* row, [In, Out] object column, [Out] 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, [Out] void* row, [In, Out] object column, [In, Out] 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, [In, Out] object row, [Out] void* column, [Out] 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, [In, Out] object row, [Out] void* column, [In, Out] 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, [In, Out] object row, [In, Out] object column, [Out] 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, [In, Out] object row, [In, Out] object column, [In, Out] 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, Int32 width, Int32 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, (Int32)width, (Int32)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, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, [In, Out] 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, (Int32)width, (Int32)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, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (Int32)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, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [In, Out] 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, (Int32)width, (Int32)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, [Out] 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 GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@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, [Out] 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 GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Histogram(GL.Enums.VERSION_1_2 target, Int32 width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glHistogram((GL.Enums.VERSION_1_2)target, (Int32)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, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage3D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage3D(GL.Enums.TextureTarget target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)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, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage3D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage3D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)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, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyTexSubImage3D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)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 MultiTexCoord1(GL.Enums.VERSION_1_3 target, Double s)
|
|
{
|
|
Delegates.glMultiTexCoord1d((GL.Enums.VERSION_1_3)target, (Double)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.VERSION_1_3 target, Single s)
|
|
{
|
|
Delegates.glMultiTexCoord1f((GL.Enums.VERSION_1_3)target, (Single)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.VERSION_1_3 target, Int32 s)
|
|
{
|
|
Delegates.glMultiTexCoord1i((GL.Enums.VERSION_1_3)target, (Int32)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.VERSION_1_3 target, Int16 s)
|
|
{
|
|
Delegates.glMultiTexCoord1s((GL.Enums.VERSION_1_3)target, (Int16)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.VERSION_1_3 target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.VERSION_1_3 target, Double s, Double t)
|
|
{
|
|
Delegates.glMultiTexCoord2d((GL.Enums.VERSION_1_3)target, (Double)s, (Double)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.VERSION_1_3 target, Single s, Single t)
|
|
{
|
|
Delegates.glMultiTexCoord2f((GL.Enums.VERSION_1_3)target, (Single)s, (Single)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.VERSION_1_3 target, Int32 s, Int32 t)
|
|
{
|
|
Delegates.glMultiTexCoord2i((GL.Enums.VERSION_1_3)target, (Int32)s, (Int32)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.VERSION_1_3 target, Int16 s, Int16 t)
|
|
{
|
|
Delegates.glMultiTexCoord2s((GL.Enums.VERSION_1_3)target, (Int16)s, (Int16)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.VERSION_1_3 target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.VERSION_1_3 target, Double s, Double t, Double r)
|
|
{
|
|
Delegates.glMultiTexCoord3d((GL.Enums.VERSION_1_3)target, (Double)s, (Double)t, (Double)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.VERSION_1_3 target, Single s, Single t, Single r)
|
|
{
|
|
Delegates.glMultiTexCoord3f((GL.Enums.VERSION_1_3)target, (Single)s, (Single)t, (Single)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.VERSION_1_3 target, Int32 s, Int32 t, Int32 r)
|
|
{
|
|
Delegates.glMultiTexCoord3i((GL.Enums.VERSION_1_3)target, (Int32)s, (Int32)t, (Int32)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.VERSION_1_3 target, Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glMultiTexCoord3s((GL.Enums.VERSION_1_3)target, (Int16)s, (Int16)t, (Int16)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.VERSION_1_3 target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.VERSION_1_3 target, Double s, Double t, Double r, Double q)
|
|
{
|
|
Delegates.glMultiTexCoord4d((GL.Enums.VERSION_1_3)target, (Double)s, (Double)t, (Double)r, (Double)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.VERSION_1_3 target, Single s, Single t, Single r, Single q)
|
|
{
|
|
Delegates.glMultiTexCoord4f((GL.Enums.VERSION_1_3)target, (Single)s, (Single)t, (Single)r, (Single)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.VERSION_1_3 target, Int32 s, Int32 t, Int32 r, Int32 q)
|
|
{
|
|
Delegates.glMultiTexCoord4i((GL.Enums.VERSION_1_3)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.VERSION_1_3 target, Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glMultiTexCoord4s((GL.Enums.VERSION_1_3)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.VERSION_1_3 target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixf(Single* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixf((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixf(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixd(Double* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixd((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixd(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixf(Single* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixf((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixf(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixf((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixd(Double* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixd((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixd(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixd((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleCoverage(Single value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleCoverage((Single)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage3D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage3D((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage3D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage2D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage2D((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage2D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage1D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage1D((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage1D(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage3D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage3D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage3D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage2D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage2D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage2D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage1D((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage1D(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCompressedTexImage(GL.Enums.TextureTarget target, Int32 level, [Out] void* img)
|
|
{
|
|
unsafe { Delegates.glGetCompressedTexImage((GL.Enums.TextureTarget)target, (Int32)level, (void*)img); }
|
|
}
|
|
|
|
public static
|
|
void GetCompressedTexImage(GL.Enums.TextureTarget target, Int32 level, [In, Out] 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, (Int32)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(Single coord)
|
|
{
|
|
Delegates.glFogCoordf((Single)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordv(Single* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoordfv((Single*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordv([In, Out] Single[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoordfv((Single*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordv(ref Single coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoordfv((Single*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordd(Double coord)
|
|
{
|
|
Delegates.glFogCoordd((Double)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordv(Double* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoorddv((Double*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordv([In, Out] Double[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoorddv((Double*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordv(ref Double coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoorddv((Double*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointer(GL.Enums.VERSION_1_4 type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointer((GL.Enums.VERSION_1_4)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointer(GL.Enums.VERSION_1_4 type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] Int32* first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] Int32* first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
first = default(Int32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] Int32* first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
first = default(Int32*);
|
|
count = default(Int32);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] out Int32 first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
count = default(Int32*);
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] out Int32 first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArrays(GL.Enums.BeginMode mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
first = *first_ptr;
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, Int32* count, GL.Enums.VERSION_1_4 type, void* indices, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (Int32*)count, (GL.Enums.VERSION_1_4)type, (void*)indices, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, Int32* count, GL.Enums.VERSION_1_4 type, [In, Out] object indices, Int32 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, (Int32*)count, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.VERSION_1_4 type, void* indices, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.VERSION_1_4 type, [In, Out] object indices, Int32 primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElements(GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.VERSION_1_4 type, void* indices, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElements(GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.VERSION_1_4 type, [In, Out] object indices, Int32 primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterf(GL.Enums.VERSION_1_4 pname, Single param)
|
|
{
|
|
Delegates.glPointParameterf((GL.Enums.VERSION_1_4)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.VERSION_1_4 pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.VERSION_1_4 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.VERSION_1_4 pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteri(GL.Enums.VERSION_1_4 pname, Int32 param)
|
|
{
|
|
Delegates.glPointParameteri((GL.Enums.VERSION_1_4)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.VERSION_1_4 pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.VERSION_1_4 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.VERSION_1_4 pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(SByte red, SByte green, SByte blue)
|
|
{
|
|
Delegates.glSecondaryColor3b((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glSecondaryColor3b((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3bv((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3bv((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bv((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Double red, Double green, Double blue)
|
|
{
|
|
Delegates.glSecondaryColor3d((Double)red, (Double)green, (Double)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Single red, Single green, Single blue)
|
|
{
|
|
Delegates.glSecondaryColor3f((Single)red, (Single)green, (Single)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3i((Int32)red, (Int32)green, (Int32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3s((Int16)red, (Int16)green, (Int16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(UInt32 red, UInt32 green, UInt32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(UInt32* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3uiv((UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(UInt16 red, UInt16 green, UInt16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3usv((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointer(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointer((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointer(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointer((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Double x, Double y)
|
|
{
|
|
Delegates.glWindowPos2d((Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Single x, Single y)
|
|
{
|
|
Delegates.glWindowPos2f((Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int32 x, Int32 y)
|
|
{
|
|
Delegates.glWindowPos2i((Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glWindowPos2s((Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glWindowPos3d((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dv((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dv((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glWindowPos3f((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fv((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fv((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glWindowPos3i((Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3iv((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3iv((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glWindowPos3s((Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3sv((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3sv((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(Int32 n, [Out] UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glGenQueries((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueries(Int32 n, [Out] Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenQueries((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueries(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueries(Int32 n, [Out] out UInt32 ids)
|
|
{
|
|
ids = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueries(Int32 n, [Out] out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(Int32 n, UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteQueries((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueries(Int32 n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteQueries((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueries(Int32 n, ref UInt32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueries(Int32 n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsQuery(UInt32 id)
|
|
{
|
|
return Delegates.glIsQuery((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
Boolean IsQuery(Int32 id)
|
|
{
|
|
return Delegates.glIsQuery((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginQuery(GL.Enums.VERSION_1_5 target, UInt32 id)
|
|
{
|
|
Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BeginQuery(GL.Enums.VERSION_1_5 target, Int32 id)
|
|
{
|
|
Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (UInt32)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 GetQueryv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(Int32 id, GL.Enums.VERSION_1_5 pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectv(Int32 id, GL.Enums.VERSION_1_5 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectv(Int32 id, GL.Enums.VERSION_1_5 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectuiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.VERSION_1_5 pname, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuiv((UInt32)id, (GL.Enums.VERSION_1_5)pname, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBuffer(GL.Enums.VERSION_1_5 target, UInt32 buffer)
|
|
{
|
|
Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void BindBuffer(GL.Enums.VERSION_1_5 target, Int32 buffer)
|
|
{
|
|
Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(Int32 n, UInt32* buffers)
|
|
{
|
|
unsafe { Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffers(Int32 n, Int32* buffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(Int32 n, [In, Out] UInt32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(Int32 n, [In, Out] Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffers(Int32 n, ref UInt32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffers(Int32 n, ref Int32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(Int32 n, [Out] UInt32* buffers)
|
|
{
|
|
unsafe { Delegates.glGenBuffers((Int32)n, (UInt32*)buffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffers(Int32 n, [Out] Int32* buffers)
|
|
{
|
|
buffers = default(Int32*);
|
|
{
|
|
Delegates.glGenBuffers((Int32)n, (UInt32*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(Int32 n, [In, Out] UInt32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(Int32 n, [In, Out] Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffers(Int32 n, [Out] out UInt32 buffers)
|
|
{
|
|
buffers = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffers(Int32 n, [Out] out Int32 buffers)
|
|
{
|
|
buffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsBuffer(UInt32 buffer)
|
|
{
|
|
return Delegates.glIsBuffer((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
Boolean IsBuffer(Int32 buffer)
|
|
{
|
|
return Delegates.glIsBuffer((UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferData(GL.Enums.VERSION_1_5 target, IntPtr size, void* data, GL.Enums.VERSION_1_5 usage)
|
|
{
|
|
unsafe { Delegates.glBufferData((GL.Enums.VERSION_1_5)target, (IntPtr)size, (void*)data, (GL.Enums.VERSION_1_5)usage); }
|
|
}
|
|
|
|
public static
|
|
void BufferData(GL.Enums.VERSION_1_5 target, IntPtr size, [In, Out] 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, (IntPtr)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, IntPtr offset, IntPtr size, void* data)
|
|
{
|
|
unsafe { Delegates.glBufferSubData((GL.Enums.VERSION_1_5)target, (IntPtr)offset, (IntPtr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void BufferSubData(GL.Enums.VERSION_1_5 target, IntPtr offset, IntPtr size, [In, Out] 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, (IntPtr)offset, (IntPtr)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferSubData(GL.Enums.VERSION_1_5 target, IntPtr offset, IntPtr size, [Out] void* data)
|
|
{
|
|
unsafe { Delegates.glGetBufferSubData((GL.Enums.VERSION_1_5)target, (IntPtr)offset, (IntPtr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferSubData(GL.Enums.VERSION_1_5 target, IntPtr offset, IntPtr size, [In, Out] 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, (IntPtr)offset, (IntPtr)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
|
|
Boolean UnmapBuffer(GL.Enums.VERSION_1_5 target)
|
|
{
|
|
return Delegates.glUnmapBuffer((GL.Enums.VERSION_1_5)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferParameterv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameterv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameterv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (Int32*)@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, [Out] 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, [In, Out] 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(Int32 n, GL.Enums.VERSION_2_0* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffers((Int32)n, (GL.Enums.VERSION_2_0*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(Int32 n, [In, Out] GL.Enums.VERSION_2_0[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.VERSION_2_0* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffers((Int32)n, (GL.Enums.VERSION_2_0*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffers(Int32 n, ref GL.Enums.VERSION_2_0 bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.VERSION_2_0* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffers((Int32)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);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, Int32 @ref, UInt32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, Int32 @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, UInt32 mask)
|
|
{
|
|
Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, Int32 mask)
|
|
{
|
|
Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (UInt32)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AttachShader(UInt32 program, UInt32 shader)
|
|
{
|
|
Delegates.glAttachShader((UInt32)program, (UInt32)shader);
|
|
}
|
|
|
|
public static
|
|
void AttachShader(Int32 program, Int32 shader)
|
|
{
|
|
Delegates.glAttachShader((UInt32)program, (UInt32)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindAttribLocation(UInt32 program, UInt32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void BindAttribLocation(Int32 program, Int32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CompileShader(UInt32 shader)
|
|
{
|
|
Delegates.glCompileShader((UInt32)shader);
|
|
}
|
|
|
|
public static
|
|
void CompileShader(Int32 shader)
|
|
{
|
|
Delegates.glCompileShader((UInt32)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);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgram(UInt32 program)
|
|
{
|
|
Delegates.glDeleteProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void DeleteProgram(Int32 program)
|
|
{
|
|
Delegates.glDeleteProgram((UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteShader(UInt32 shader)
|
|
{
|
|
Delegates.glDeleteShader((UInt32)shader);
|
|
}
|
|
|
|
public static
|
|
void DeleteShader(Int32 shader)
|
|
{
|
|
Delegates.glDeleteShader((UInt32)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DetachShader(UInt32 program, UInt32 shader)
|
|
{
|
|
Delegates.glDetachShader((UInt32)program, (UInt32)shader);
|
|
}
|
|
|
|
public static
|
|
void DetachShader(Int32 program, Int32 shader)
|
|
{
|
|
Delegates.glDetachShader((UInt32)program, (UInt32)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVertexAttribArray(UInt32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArray((UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void DisableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArray((UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVertexAttribArray(UInt32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArray((UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void EnableVertexAttribArray(Int32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArray((UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (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, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (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, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.VERSION_2_0* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.VERSION_2_0[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.VERSION_2_0 type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.VERSION_2_0);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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(UInt32 program, Int32 maxCount, [Out] Int32* count, [Out] UInt32* obj)
|
|
{
|
|
unsafe { Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32* count, [Out] Int32* obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(Int32*);
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32* count, [In, Out] UInt32[] obj)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32* count, [In, Out] Int32[] obj)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32* count, [Out] out UInt32 obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(UInt32);
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32* count, [Out] out Int32 obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(Int32);
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [In, Out] Int32[] count, [Out] UInt32* obj)
|
|
{
|
|
obj = default(UInt32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [In, Out] Int32[] count, [Out] Int32* obj)
|
|
{
|
|
obj = default(Int32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(UInt32 program, Int32 maxCount, [In, Out] Int32[] count, [In, Out] UInt32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, Int32 maxCount, [In, Out] Int32[] count, [In, Out] Int32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(UInt32 program, Int32 maxCount, [In, Out] Int32[] count, [Out] out UInt32 obj)
|
|
{
|
|
obj = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, Int32 maxCount, [In, Out] Int32[] count, [Out] out Int32 obj)
|
|
{
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] UInt32* obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(UInt32*);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] Int32* obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(Int32*);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [In, Out] UInt32[] obj)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [In, Out] Int32[] obj)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetAttribLocation(UInt32 program, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetAttribLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramv(UInt32 program, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramv(Int32 program, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramv(UInt32 program, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(Int32 program, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramv(UInt32 program, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(Int32 program, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramiv((UInt32)program, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramInfoLog(Int32 program, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramInfoLog(UInt32 program, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramInfoLog(Int32 program, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramInfoLog(Int32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderv(UInt32 shader, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderv(Int32 shader, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderv(UInt32 shader, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderv(Int32 shader, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderv(UInt32 shader, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderv(Int32 shader, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetShaderiv((UInt32)shader, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderInfoLog(Int32 shader, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(UInt32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
unsafe { Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSource(Int32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32*);
|
|
source = default(System.Text.StringBuilder[]);
|
|
{
|
|
Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(UInt32 shader, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 shader, Int32 bufSize, [In, Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSource(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSource(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetUniformLocation(UInt32 program, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetUniformLocation(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(UInt32 program, Int32 location, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(Int32 program, Int32 location, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(UInt32 program, Int32 location, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(Int32 program, Int32 location, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribiv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(UInt32 index, GL.Enums.VERSION_2_0 pname, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointerv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, [Out] void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointerv(UInt32 index, GL.Enums.VERSION_2_0 pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointerv((UInt32)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsProgram(UInt32 program)
|
|
{
|
|
return Delegates.glIsProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
Boolean IsProgram(Int32 program)
|
|
{
|
|
return Delegates.glIsProgram((UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsShader(UInt32 shader)
|
|
{
|
|
return Delegates.glIsShader((UInt32)shader);
|
|
}
|
|
|
|
public static
|
|
Boolean IsShader(Int32 shader)
|
|
{
|
|
return Delegates.glIsShader((UInt32)shader);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LinkProgram(UInt32 program)
|
|
{
|
|
Delegates.glLinkProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void LinkProgram(Int32 program)
|
|
{
|
|
Delegates.glLinkProgram((UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, Int32* length)
|
|
{
|
|
unsafe { Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSource(Int32 shader, Int32 count, System.String[] @string, Int32* length)
|
|
{
|
|
{
|
|
Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, [In, Out] Int32[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shader, Int32 count, System.String[] @string, [In, Out] Int32[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, ref Int32 length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSource(Int32 shader, Int32 count, System.String[] @string, ref Int32 length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UseProgram(UInt32 program)
|
|
{
|
|
Delegates.glUseProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void UseProgram(Int32 program)
|
|
{
|
|
Delegates.glUseProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void Uniform1(Int32 location, Single v0)
|
|
{
|
|
Delegates.glUniform1f((Int32)location, (Single)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2(Int32 location, Single v0, Single v1)
|
|
{
|
|
Delegates.glUniform2f((Int32)location, (Single)v0, (Single)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3(Int32 location, Single v0, Single v1, Single v2)
|
|
{
|
|
Delegates.glUniform3f((Int32)location, (Single)v0, (Single)v1, (Single)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4(Int32 location, Single v0, Single v1, Single v2, Single v3)
|
|
{
|
|
Delegates.glUniform4f((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
|
|
}
|
|
|
|
public static
|
|
void Uniform1(Int32 location, Int32 v0)
|
|
{
|
|
Delegates.glUniform1i((Int32)location, (Int32)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2(Int32 location, Int32 v0, Int32 v1)
|
|
{
|
|
Delegates.glUniform2i((Int32)location, (Int32)v0, (Int32)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
|
|
{
|
|
Delegates.glUniform3i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
|
|
{
|
|
Delegates.glUniform4i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ValidateProgram(UInt32 program)
|
|
{
|
|
Delegates.glValidateProgram((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void ValidateProgram(Int32 program)
|
|
{
|
|
Delegates.glValidateProgram((UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, SByte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4N(UInt32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4N(Int32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, SByte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(UInt32 index, Int32 size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointer(Int32 index, Int32 size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, Int32 stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (Int32)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2x3v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3x2v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2x4v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4x2v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3x4v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4x3v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointervINTEL(Int32 size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointervINTEL((Int32)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointervINTEL(Int32 size, GL.Enums.VertexPointerType type, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointervINTEL((Int32)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, [In, Out] 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(Int32 size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointervINTEL((Int32)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointervINTEL(Int32 size, GL.Enums.VertexPointerType type, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointervINTEL((Int32)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointervINTEL(Int32 size, GL.Enums.VertexPointerType type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointervINTEL((Int32)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointervINTEL(Int32 size, GL.Enums.VertexPointerType type, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointervINTEL((Int32)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TbufferMask3DFX(UInt32 mask)
|
|
{
|
|
Delegates.glTbufferMask3DFX((UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void TbufferMask3DFX(Int32 mask)
|
|
{
|
|
Delegates.glTbufferMask3DFX((UInt32)mask);
|
|
}
|
|
|
|
public static class ARB
|
|
{
|
|
public static
|
|
void ActiveTextureARB(GL.Enums.ARB_multitexture texture)
|
|
{
|
|
Delegates.glActiveTextureARB((GL.Enums.ARB_multitexture)texture);
|
|
}
|
|
|
|
public static
|
|
void ClientActiveTextureARB(GL.Enums.ARB_multitexture texture)
|
|
{
|
|
Delegates.glClientActiveTextureARB((GL.Enums.ARB_multitexture)texture);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.ARB_multitexture target, Double s)
|
|
{
|
|
Delegates.glMultiTexCoord1dARB((GL.Enums.ARB_multitexture)target, (Double)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.ARB_multitexture target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.ARB_multitexture target, Single s)
|
|
{
|
|
Delegates.glMultiTexCoord1fARB((GL.Enums.ARB_multitexture)target, (Single)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.ARB_multitexture target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.ARB_multitexture target, Int32 s)
|
|
{
|
|
Delegates.glMultiTexCoord1iARB((GL.Enums.ARB_multitexture)target, (Int32)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.ARB_multitexture target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1(GL.Enums.ARB_multitexture target, Int16 s)
|
|
{
|
|
Delegates.glMultiTexCoord1sARB((GL.Enums.ARB_multitexture)target, (Int16)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1v(GL.Enums.ARB_multitexture target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1v(GL.Enums.ARB_multitexture target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.ARB_multitexture target, Double s, Double t)
|
|
{
|
|
Delegates.glMultiTexCoord2dARB((GL.Enums.ARB_multitexture)target, (Double)s, (Double)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.ARB_multitexture target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.ARB_multitexture target, Single s, Single t)
|
|
{
|
|
Delegates.glMultiTexCoord2fARB((GL.Enums.ARB_multitexture)target, (Single)s, (Single)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.ARB_multitexture target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.ARB_multitexture target, Int32 s, Int32 t)
|
|
{
|
|
Delegates.glMultiTexCoord2iARB((GL.Enums.ARB_multitexture)target, (Int32)s, (Int32)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.ARB_multitexture target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2(GL.Enums.ARB_multitexture target, Int16 s, Int16 t)
|
|
{
|
|
Delegates.glMultiTexCoord2sARB((GL.Enums.ARB_multitexture)target, (Int16)s, (Int16)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2v(GL.Enums.ARB_multitexture target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2v(GL.Enums.ARB_multitexture target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.ARB_multitexture target, Double s, Double t, Double r)
|
|
{
|
|
Delegates.glMultiTexCoord3dARB((GL.Enums.ARB_multitexture)target, (Double)s, (Double)t, (Double)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.ARB_multitexture target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.ARB_multitexture target, Single s, Single t, Single r)
|
|
{
|
|
Delegates.glMultiTexCoord3fARB((GL.Enums.ARB_multitexture)target, (Single)s, (Single)t, (Single)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.ARB_multitexture target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.ARB_multitexture target, Int32 s, Int32 t, Int32 r)
|
|
{
|
|
Delegates.glMultiTexCoord3iARB((GL.Enums.ARB_multitexture)target, (Int32)s, (Int32)t, (Int32)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.ARB_multitexture target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3(GL.Enums.ARB_multitexture target, Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glMultiTexCoord3sARB((GL.Enums.ARB_multitexture)target, (Int16)s, (Int16)t, (Int16)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3v(GL.Enums.ARB_multitexture target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3v(GL.Enums.ARB_multitexture target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.ARB_multitexture target, Double s, Double t, Double r, Double q)
|
|
{
|
|
Delegates.glMultiTexCoord4dARB((GL.Enums.ARB_multitexture)target, (Double)s, (Double)t, (Double)r, (Double)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.ARB_multitexture target, Double* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.ARB_multitexture target, Single s, Single t, Single r, Single q)
|
|
{
|
|
Delegates.glMultiTexCoord4fARB((GL.Enums.ARB_multitexture)target, (Single)s, (Single)t, (Single)r, (Single)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.ARB_multitexture target, Single* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.ARB_multitexture target, Int32 s, Int32 t, Int32 r, Int32 q)
|
|
{
|
|
Delegates.glMultiTexCoord4iARB((GL.Enums.ARB_multitexture)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.ARB_multitexture target, Int32* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4(GL.Enums.ARB_multitexture target, Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glMultiTexCoord4sARB((GL.Enums.ARB_multitexture)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4v(GL.Enums.ARB_multitexture target, Int16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4v(GL.Enums.ARB_multitexture target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixfARB(Single* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixfARB((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixfARB([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixfARB(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadTransposeMatrixdARB(Double* m)
|
|
{
|
|
unsafe { Delegates.glLoadTransposeMatrixdARB((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixdARB([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadTransposeMatrixdARB(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixfARB(Single* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixfARB((Single*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixfARB([In, Out] Single[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixfARB(ref Single m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultTransposeMatrixdARB(Double* m)
|
|
{
|
|
unsafe { Delegates.glMultTransposeMatrixdARB((Double*)m); }
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixdARB([In, Out] Double[] m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = m)
|
|
{
|
|
Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultTransposeMatrixdARB(ref Double m)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* m_ptr = &m)
|
|
{
|
|
Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleCoverageARB(Single value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleCoverageARB((Single)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage3DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage3DARB((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage3DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage2DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage2DARB((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage2DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexImage1DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexImage1DARB((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexImage1DARB(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage3DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage3DARB((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage3DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage2DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage2DARB((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage2DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CompressedTexSubImage1DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, Int32 imageSize, void* data)
|
|
{
|
|
unsafe { Delegates.glCompressedTexSubImage1DARB((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void CompressedTexSubImage1DARB(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, Int32 imageSize, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (Int32)imageSize, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCompressedTexImageARB(GL.Enums.TextureTarget target, Int32 level, [Out] void* img)
|
|
{
|
|
unsafe { Delegates.glGetCompressedTexImageARB((GL.Enums.TextureTarget)target, (Int32)level, (void*)img); }
|
|
}
|
|
|
|
public static
|
|
void GetCompressedTexImageARB(GL.Enums.TextureTarget target, Int32 level, [In, Out] 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, (Int32)level, (void*)img_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
img_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterfARB(GL.Enums.ARB_point_parameters pname, Single param)
|
|
{
|
|
Delegates.glPointParameterfARB((GL.Enums.ARB_point_parameters)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.ARB_point_parameters pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.ARB_point_parameters pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.ARB_point_parameters pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, SByte* weights)
|
|
{
|
|
unsafe { Delegates.glWeightbvARB((Int32)size, (SByte*)weights); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, Byte* weights)
|
|
{
|
|
{
|
|
Delegates.glWeightbvARB((Int32)size, (SByte*)weights);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] SByte[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] Byte[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, ref SByte weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, ref Byte weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, Int16* weights)
|
|
{
|
|
unsafe { Delegates.glWeightsvARB((Int32)size, (Int16*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] Int16[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightsvARB((Int32)size, (Int16*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, ref Int16 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightsvARB((Int32)size, (Int16*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, Int32* weights)
|
|
{
|
|
unsafe { Delegates.glWeightivARB((Int32)size, (Int32*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] Int32[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightivARB((Int32)size, (Int32*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, ref Int32 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightivARB((Int32)size, (Int32*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, Single* weights)
|
|
{
|
|
unsafe { Delegates.glWeightfvARB((Int32)size, (Single*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] Single[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, ref Single weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, Double* weights)
|
|
{
|
|
unsafe { Delegates.glWeightdvARB((Int32)size, (Double*)weights); }
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] Double[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Weightv(Int32 size, ref Double weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, UInt16* weights)
|
|
{
|
|
unsafe { Delegates.glWeightusvARB((Int32)size, (UInt16*)weights); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] UInt16[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, ref UInt16 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Weightv(Int32 size, UInt32* weights)
|
|
{
|
|
unsafe { Delegates.glWeightuivARB((Int32)size, (UInt32*)weights); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, [In, Out] UInt32[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* weights_ptr = weights)
|
|
{
|
|
Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Weightv(Int32 size, ref UInt32 weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* weights_ptr = &weights)
|
|
{
|
|
Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WeightPointerARB(Int32 size, GL.Enums.ARB_vertex_blend type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glWeightPointerARB((Int32)size, (GL.Enums.ARB_vertex_blend)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void WeightPointerARB(Int32 size, GL.Enums.ARB_vertex_blend type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glWeightPointerARB((Int32)size, (GL.Enums.ARB_vertex_blend)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexBlendARB(Int32 count)
|
|
{
|
|
Delegates.glVertexBlendARB((Int32)count);
|
|
}
|
|
|
|
public static
|
|
void CurrentPaletteMatrixARB(Int32 index)
|
|
{
|
|
Delegates.glCurrentPaletteMatrixARB((Int32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexv(Int32 size, Byte* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, [In, Out] Byte[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, ref Byte indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexv(Int32 size, UInt16* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexv(Int32 size, Int16* indices)
|
|
{
|
|
{
|
|
Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexv(Int32 size, [In, Out] UInt16[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, [In, Out] Int16[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexv(Int32 size, ref UInt16 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, ref Int16 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexv(Int32 size, UInt32* indices)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexv(Int32 size, Int32* indices)
|
|
{
|
|
{
|
|
Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexv(Int32 size, [In, Out] UInt32[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, [In, Out] Int32[] indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* indices_ptr = indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MatrixIndexv(Int32 size, ref UInt32 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexv(Int32 size, ref Int32 indices)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* indices_ptr = &indices)
|
|
{
|
|
Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MatrixIndexPointerARB(Int32 size, GL.Enums.ARB_matrix_palette type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glMatrixIndexPointerARB((Int32)size, (GL.Enums.ARB_matrix_palette)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void MatrixIndexPointerARB(Int32 size, GL.Enums.ARB_matrix_palette type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glMatrixIndexPointerARB((Int32)size, (GL.Enums.ARB_matrix_palette)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Double x, Double y)
|
|
{
|
|
Delegates.glWindowPos2dARB((Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dvARB((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dvARB((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dvARB((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Single x, Single y)
|
|
{
|
|
Delegates.glWindowPos2fARB((Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fvARB((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fvARB((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fvARB((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int32 x, Int32 y)
|
|
{
|
|
Delegates.glWindowPos2iARB((Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2ivARB((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2ivARB((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2ivARB((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glWindowPos2sARB((Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2svARB((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2svARB((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2svARB((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glWindowPos3dARB((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dvARB((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dvARB((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dvARB((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glWindowPos3fARB((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fvARB((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fvARB((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fvARB((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glWindowPos3iARB((Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3ivARB((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3ivARB((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3ivARB((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glWindowPos3sARB((Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3svARB((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3svARB((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3svARB((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, SByte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4Nv(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4N(UInt32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4N(Int32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4Nv(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4Nv(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, SByte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointerARB(UInt32 index, Int32 size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointerARB(Int32 index, Int32 size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, Int32 stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (Int32)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVertexAttribArrayARB(UInt32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArrayARB((UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void EnableVertexAttribArrayARB(Int32 index)
|
|
{
|
|
Delegates.glEnableVertexAttribArrayARB((UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVertexAttribArrayARB(UInt32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArrayARB((UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void DisableVertexAttribArrayARB(Int32 index)
|
|
{
|
|
Delegates.glDisableVertexAttribArrayARB((UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramStringARB(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, Int32 len, void* @string)
|
|
{
|
|
unsafe { Delegates.glProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)format, (Int32)len, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void ProgramStringARB(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, Int32 len, [In, Out] 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, (Int32)len, (void*)@string_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@string_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindProgramARB(GL.Enums.ARB_vertex_program target, UInt32 program)
|
|
{
|
|
Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (UInt32)program);
|
|
}
|
|
|
|
public static
|
|
void BindProgramARB(GL.Enums.ARB_vertex_program target, Int32 program)
|
|
{
|
|
Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteProgramsARB(Int32 n, UInt32* programs)
|
|
{
|
|
unsafe { Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteProgramsARB(Int32 n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgramsARB(Int32 n, [In, Out] UInt32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteProgramsARB(Int32 n, [In, Out] Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgramsARB(Int32 n, ref UInt32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteProgramsARB(Int32 n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenProgramsARB(Int32 n, [Out] UInt32* programs)
|
|
{
|
|
unsafe { Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenProgramsARB(Int32 n, [Out] Int32* programs)
|
|
{
|
|
programs = default(Int32*);
|
|
{
|
|
Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenProgramsARB(Int32 n, [In, Out] UInt32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenProgramsARB(Int32 n, [In, Out] Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenProgramsARB(Int32 n, [Out] out UInt32 programs)
|
|
{
|
|
programs = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenProgramsARB(Int32 n, [Out] out Int32 programs)
|
|
{
|
|
programs = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4(GL.Enums.ARB_vertex_program target, UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4(GL.Enums.ARB_vertex_program target, Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, Double* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, Double* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, ref Double @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, ref Double @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4(GL.Enums.ARB_vertex_program target, UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4(GL.Enums.ARB_vertex_program target, Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, Single* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4(GL.Enums.ARB_vertex_program target, UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4(GL.Enums.ARB_vertex_program target, Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, Double* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, Double* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, ref Double @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, ref Double @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4(GL.Enums.ARB_vertex_program target, UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4(GL.Enums.ARB_vertex_program target, Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, Single* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, UInt32 index, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameter4v(GL.Enums.ARB_vertex_program target, Int32 index, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, UInt32 index, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterv(GL.Enums.ARB_vertex_program target, Int32 index, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (UInt32)index, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramStringARB(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, [Out] void* @string)
|
|
{
|
|
unsafe { Delegates.glGetProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void GetProgramStringARB(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, [In, Out] 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 GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointervARB(UInt32 index, GL.Enums.ARB_vertex_program pname, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointervARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointervARB(Int32 index, GL.Enums.ARB_vertex_program pname, [Out] void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointervARB(UInt32 index, GL.Enums.ARB_vertex_program pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointervARB(Int32 index, GL.Enums.ARB_vertex_program pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervARB((UInt32)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsProgramARB(UInt32 program)
|
|
{
|
|
return Delegates.glIsProgramARB((UInt32)program);
|
|
}
|
|
|
|
public static
|
|
Boolean IsProgramARB(Int32 program)
|
|
{
|
|
return Delegates.glIsProgramARB((UInt32)program);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferARB(GL.Enums.ARB_vertex_buffer_object target, UInt32 buffer)
|
|
{
|
|
Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void BindBufferARB(GL.Enums.ARB_vertex_buffer_object target, Int32 buffer)
|
|
{
|
|
Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffersARB(Int32 n, UInt32* buffers)
|
|
{
|
|
unsafe { Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteBuffersARB(Int32 n, Int32* buffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffersARB(Int32 n, [In, Out] UInt32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffersARB(Int32 n, [In, Out] Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteBuffersARB(Int32 n, ref UInt32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteBuffersARB(Int32 n, ref Int32 buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffersARB(Int32 n, [Out] UInt32* buffers)
|
|
{
|
|
unsafe { Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenBuffersARB(Int32 n, [Out] Int32* buffers)
|
|
{
|
|
buffers = default(Int32*);
|
|
{
|
|
Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffersARB(Int32 n, [In, Out] UInt32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffersARB(Int32 n, [In, Out] Int32[] buffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenBuffersARB(Int32 n, [Out] out UInt32 buffers)
|
|
{
|
|
buffers = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenBuffersARB(Int32 n, [Out] out Int32 buffers)
|
|
{
|
|
buffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffers_ptr = &buffers)
|
|
{
|
|
Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
|
|
buffers = *buffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsBufferARB(UInt32 buffer)
|
|
{
|
|
return Delegates.glIsBufferARB((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
Boolean IsBufferARB(Int32 buffer)
|
|
{
|
|
return Delegates.glIsBufferARB((UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr size, void* data, GL.Enums.ARB_vertex_buffer_object usage)
|
|
{
|
|
unsafe { Delegates.glBufferDataARB((GL.Enums.ARB_vertex_buffer_object)target, (IntPtr)size, (void*)data, (GL.Enums.ARB_vertex_buffer_object)usage); }
|
|
}
|
|
|
|
public static
|
|
void BufferDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr size, [In, Out] 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, (IntPtr)size, (void*)data_ptr.AddrOfPinnedObject(), (GL.Enums.ARB_vertex_buffer_object)usage);
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BufferSubDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr offset, IntPtr size, void* data)
|
|
{
|
|
unsafe { Delegates.glBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (IntPtr)offset, (IntPtr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void BufferSubDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr offset, IntPtr size, [In, Out] 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, (IntPtr)offset, (IntPtr)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferSubDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr offset, IntPtr size, [Out] void* data)
|
|
{
|
|
unsafe { Delegates.glGetBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (IntPtr)offset, (IntPtr)size, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferSubDataARB(GL.Enums.ARB_vertex_buffer_object target, IntPtr offset, IntPtr size, [In, Out] 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, (IntPtr)offset, (IntPtr)size, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
IntPtr MapBufferARB(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
|
|
Boolean UnmapBufferARB(GL.Enums.ARB_vertex_buffer_object target)
|
|
{
|
|
return Delegates.glUnmapBufferARB((GL.Enums.ARB_vertex_buffer_object)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferParameterv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameterv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetBufferParameterv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBufferPointervARB(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, [Out] void* @params)
|
|
{
|
|
unsafe { Delegates.glGetBufferPointervARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetBufferPointervARB(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, [In, Out] 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 GenQueriesARB(Int32 n, [Out] UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenQueriesARB(Int32 n, [Out] Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueriesARB(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueriesARB(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenQueriesARB(Int32 n, [Out] out UInt32 ids)
|
|
{
|
|
ids = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenQueriesARB(Int32 n, [Out] out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueriesARB(Int32 n, UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteQueriesARB(Int32 n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueriesARB(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueriesARB(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteQueriesARB(Int32 n, ref UInt32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteQueriesARB(Int32 n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsQueryARB(UInt32 id)
|
|
{
|
|
return Delegates.glIsQueryARB((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
Boolean IsQueryARB(Int32 id)
|
|
{
|
|
return Delegates.glIsQueryARB((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginQueryARB(GL.Enums.ARB_occlusion_query target, UInt32 id)
|
|
{
|
|
Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BeginQueryARB(GL.Enums.ARB_occlusion_query target, Int32 id)
|
|
{
|
|
Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void EndQueryARB(GL.Enums.ARB_occlusion_query target)
|
|
{
|
|
Delegates.glEndQueryARB((GL.Enums.ARB_occlusion_query)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetQueryv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(Int32 id, GL.Enums.ARB_occlusion_query pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectv(Int32 id, GL.Enums.ARB_occlusion_query pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectv(Int32 id, GL.Enums.ARB_occlusion_query pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectuivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectv(UInt32 id, GL.Enums.ARB_occlusion_query pname, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectuivARB((UInt32)id, (GL.Enums.ARB_occlusion_query)pname, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteObjectARB(UInt32 obj)
|
|
{
|
|
Delegates.glDeleteObjectARB((UInt32)obj);
|
|
}
|
|
|
|
public static
|
|
void DeleteObjectARB(Int32 obj)
|
|
{
|
|
Delegates.glDeleteObjectARB((UInt32)obj);
|
|
}
|
|
|
|
public static
|
|
Int32 GetHandleARB(GL.Enums.ARB_shader_objects pname)
|
|
{
|
|
return Delegates.glGetHandleARB((GL.Enums.ARB_shader_objects)pname);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DetachObjectARB(UInt32 containerObj, UInt32 attachedObj)
|
|
{
|
|
Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
|
|
}
|
|
|
|
public static
|
|
void DetachObjectARB(Int32 containerObj, Int32 attachedObj)
|
|
{
|
|
Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
|
|
}
|
|
|
|
public static
|
|
Int32 CreateShaderObjectARB(GL.Enums.ARB_shader_objects shaderType)
|
|
{
|
|
return Delegates.glCreateShaderObjectARB((GL.Enums.ARB_shader_objects)shaderType);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, Int32* length)
|
|
{
|
|
unsafe { Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, Int32* length)
|
|
{
|
|
{
|
|
Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, [In, Out] Int32[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, [In, Out] Int32[] length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void CompileShaderARB(UInt32 shaderObj)
|
|
{
|
|
Delegates.glCompileShaderARB((UInt32)shaderObj);
|
|
}
|
|
|
|
public static
|
|
void CompileShaderARB(Int32 shaderObj)
|
|
{
|
|
Delegates.glCompileShaderARB((UInt32)shaderObj);
|
|
}
|
|
|
|
public static
|
|
Int32 CreateProgramObjectARB()
|
|
{
|
|
return Delegates.glCreateProgramObjectARB();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AttachObjectARB(UInt32 containerObj, UInt32 obj)
|
|
{
|
|
Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
|
|
}
|
|
|
|
public static
|
|
void AttachObjectARB(Int32 containerObj, Int32 obj)
|
|
{
|
|
Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LinkProgramARB(UInt32 programObj)
|
|
{
|
|
Delegates.glLinkProgramARB((UInt32)programObj);
|
|
}
|
|
|
|
public static
|
|
void LinkProgramARB(Int32 programObj)
|
|
{
|
|
Delegates.glLinkProgramARB((UInt32)programObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UseProgramObjectARB(UInt32 programObj)
|
|
{
|
|
Delegates.glUseProgramObjectARB((UInt32)programObj);
|
|
}
|
|
|
|
public static
|
|
void UseProgramObjectARB(Int32 programObj)
|
|
{
|
|
Delegates.glUseProgramObjectARB((UInt32)programObj);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ValidateProgramARB(UInt32 programObj)
|
|
{
|
|
Delegates.glValidateProgramARB((UInt32)programObj);
|
|
}
|
|
|
|
public static
|
|
void ValidateProgramARB(Int32 programObj)
|
|
{
|
|
Delegates.glValidateProgramARB((UInt32)programObj);
|
|
}
|
|
|
|
public static
|
|
void Uniform1(Int32 location, Single v0)
|
|
{
|
|
Delegates.glUniform1fARB((Int32)location, (Single)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2(Int32 location, Single v0, Single v1)
|
|
{
|
|
Delegates.glUniform2fARB((Int32)location, (Single)v0, (Single)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3(Int32 location, Single v0, Single v1, Single v2)
|
|
{
|
|
Delegates.glUniform3fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4(Int32 location, Single v0, Single v1, Single v2, Single v3)
|
|
{
|
|
Delegates.glUniform4fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
|
|
}
|
|
|
|
public static
|
|
void Uniform1(Int32 location, Int32 v0)
|
|
{
|
|
Delegates.glUniform1iARB((Int32)location, (Int32)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform2(Int32 location, Int32 v0, Int32 v1)
|
|
{
|
|
Delegates.glUniform2iARB((Int32)location, (Int32)v0, (Int32)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
|
|
{
|
|
Delegates.glUniform3iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
|
|
{
|
|
Delegates.glUniform4iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
unsafe { Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value); }
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix2v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix3v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UniformMatrix4v(Int32 location, Int32 count, GL.Enums.Boolean transpose, Single* value)
|
|
{
|
|
unsafe { Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (GL.Enums.Boolean)transpose, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterfvARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectParameterv(UInt32 obj, GL.Enums.ARB_shader_objects pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectParameterv(Int32 obj, GL.Enums.ARB_shader_objects pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectParameterivARB((UInt32)obj, (GL.Enums.ARB_shader_objects)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInfoLogARB(UInt32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
unsafe { Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInfoLogARB(Int32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32*);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInfoLogARB(UInt32 obj, Int32 maxLength, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInfoLogARB(Int32 obj, Int32 maxLength, [In, Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInfoLogARB(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInfoLogARB(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
|
|
{
|
|
length = default(Int32);
|
|
infoLog = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] UInt32* obj)
|
|
{
|
|
unsafe { Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] Int32* obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(Int32*);
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32* count, [In, Out] UInt32[] obj)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32* count, [In, Out] Int32[] obj)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] out UInt32 obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(UInt32);
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] out Int32 obj)
|
|
{
|
|
count = default(Int32*);
|
|
obj = default(Int32);
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [Out] UInt32* obj)
|
|
{
|
|
obj = default(UInt32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [Out] Int32* obj)
|
|
{
|
|
obj = default(Int32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [In, Out] UInt32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [In, Out] Int32[] obj)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [Out] out UInt32 obj)
|
|
{
|
|
obj = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [In, Out] Int32[] count, [Out] out Int32 obj)
|
|
{
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] UInt32* obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(UInt32*);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] Int32* obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(Int32*);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [In, Out] UInt32[] obj)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (UInt32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [In, Out] Int32[] obj)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (UInt32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
|
|
{
|
|
count = default(Int32);
|
|
obj = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
fixed (Int32* obj_ptr = &obj)
|
|
{
|
|
Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
|
|
count = *count_ptr;
|
|
obj = *obj_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetUniformLocationARB(UInt32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetUniformLocationARB(Int32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)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 GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)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 GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.ARB_shader_objects* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_shader_objects[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.ARB_shader_objects type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_shader_objects);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetUniformv(UInt32 programObj, Int32 location, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(Int32 programObj, Int32 location, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 programObj, Int32 location, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 programObj, Int32 location, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 programObj, Int32 location, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 programObj, Int32 location, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(UInt32 programObj, Int32 location, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(Int32 programObj, Int32 location, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 programObj, Int32 location, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 programObj, Int32 location, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 programObj, Int32 location, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 programObj, Int32 location, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSourceARB(UInt32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
unsafe { Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetShaderSourceARB(Int32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32*);
|
|
source = default(System.Text.StringBuilder[]);
|
|
{
|
|
Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSourceARB(UInt32 obj, Int32 maxLength, [In, Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSourceARB(Int32 obj, Int32 maxLength, [In, Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetShaderSourceARB(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetShaderSourceARB(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
|
|
{
|
|
length = default(Int32);
|
|
source = default(System.Text.StringBuilder[]);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindAttribLocationARB(UInt32 programObj, UInt32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void BindAttribLocationARB(Int32 programObj, Int32 index, System.String name)
|
|
{
|
|
Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)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 GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)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 GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.ARB_vertex_shader* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.ARB_vertex_shader[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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 GetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.ARB_vertex_shader type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.ARB_vertex_shader);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)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
|
|
Int32 GetAttribLocationARB(UInt32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetAttribLocationARB(Int32 programObj, System.String name)
|
|
{
|
|
return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawBuffersARB(Int32 n, GL.Enums.ARB_draw_buffers* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffersARB((Int32)n, (GL.Enums.ARB_draw_buffers*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffersARB(Int32 n, [In, Out] GL.Enums.ARB_draw_buffers[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffersARB((Int32)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffersARB(Int32 n, ref GL.Enums.ARB_draw_buffers bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffersARB((Int32)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClampColorARB(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 BlendColorEXT(Single red, Single green, Single blue, Single alpha)
|
|
{
|
|
Delegates.glBlendColorEXT((Single)red, (Single)green, (Single)blue, (Single)alpha);
|
|
}
|
|
|
|
public static
|
|
void PolygonOffsetEXT(Single factor, Single bias)
|
|
{
|
|
Delegates.glPolygonOffsetEXT((Single)factor, (Single)bias);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage3DEXT(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage3DEXT((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage3DEXT(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage3DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage3DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage3DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage1DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage1DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage1DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage2DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage2DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage2DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage1DEXT(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
|
|
{
|
|
Delegates.glCopyTexImage1DEXT((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexImage2DEXT(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
|
|
{
|
|
Delegates.glCopyTexImage2DEXT((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage1DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyTexSubImage1DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage2DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyTexSubImage2DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
public static
|
|
void CopyTexSubImage3DEXT(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyTexSubImage3DEXT((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramEXT(GL.Enums.HistogramTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] 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 GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetHistogramParameterv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxEXT(GL.Enums.MinmaxTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] 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 GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMinmaxParameterv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void HistogramEXT(GL.Enums.HistogramTargetEXT target, Int32 width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
|
|
{
|
|
Delegates.glHistogramEXT((GL.Enums.HistogramTargetEXT)target, (Int32)width, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink);
|
|
}
|
|
|
|
public static
|
|
void MinmaxEXT(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 ResetHistogramEXT(GL.Enums.HistogramTargetEXT target)
|
|
{
|
|
Delegates.glResetHistogramEXT((GL.Enums.HistogramTargetEXT)target);
|
|
}
|
|
|
|
public static
|
|
void ResetMinmaxEXT(GL.Enums.MinmaxTargetEXT target)
|
|
{
|
|
Delegates.glResetMinmaxEXT((GL.Enums.MinmaxTargetEXT)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter1DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter1DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionFilter2DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
|
|
{
|
|
unsafe { Delegates.glConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionFilter2DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
image_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterfEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, Single @params)
|
|
{
|
|
Delegates.glConvolutionParameterfEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameteriEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, Int32 @params)
|
|
{
|
|
Delegates.glConvolutionParameteriEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32)@params);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter1DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
public static
|
|
void CopyConvolutionFilter2DEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glCopyConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionFilterEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* image)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionFilterEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionFilterEXT(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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 GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetConvolutionParameterv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* row, [Out] void* column, [Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* row, [Out] void* column, [In, Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* row, [In, Out] object column, [Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* row, [In, Out] object column, [In, Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [Out] void* column, [Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [Out] void* column, [In, Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [In, Out] object column, [Out] 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 GetSeparableFilterEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [In, Out] object column, [In, Out] 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 SeparableFilter2DEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column)
|
|
{
|
|
unsafe { Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SeparableFilter2DEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, [In, Out] 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, (Int32)width, (Int32)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 SeparableFilter2DEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (Int32)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column);
|
|
}
|
|
finally
|
|
{
|
|
row_ptr.Free();
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SeparableFilter2DEXT(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] object row, [In, Out] 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, (Int32)width, (Int32)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 Boolean AreTexturesResidentEXT(Int32 n, UInt32* textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResidentEXT(Int32 n, Int32* textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResidentEXT(Int32 n, [In, Out] UInt32[] textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResidentEXT(Int32 n, [In, Out] Int32[] textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResidentEXT(Int32 n, ref UInt32 textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreTexturesResidentEXT(Int32 n, ref Int32 textures, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Boolean retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindTextureEXT(GL.Enums.TextureTarget target, UInt32 texture)
|
|
{
|
|
Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (UInt32)texture);
|
|
}
|
|
|
|
public static
|
|
void BindTextureEXT(GL.Enums.TextureTarget target, Int32 texture)
|
|
{
|
|
Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (UInt32)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTexturesEXT(Int32 n, UInt32* textures)
|
|
{
|
|
unsafe { Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteTexturesEXT(Int32 n, Int32* textures)
|
|
{
|
|
{
|
|
Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTexturesEXT(Int32 n, [In, Out] UInt32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTexturesEXT(Int32 n, [In, Out] Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteTexturesEXT(Int32 n, ref UInt32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteTexturesEXT(Int32 n, ref Int32 textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTexturesEXT(Int32 n, [Out] UInt32* textures)
|
|
{
|
|
unsafe { Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenTexturesEXT(Int32 n, [Out] Int32* textures)
|
|
{
|
|
textures = default(Int32*);
|
|
{
|
|
Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTexturesEXT(Int32 n, [In, Out] UInt32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTexturesEXT(Int32 n, [In, Out] Int32[] textures)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenTexturesEXT(Int32 n, [Out] out UInt32 textures)
|
|
{
|
|
textures = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenTexturesEXT(Int32 n, [Out] out Int32 textures)
|
|
{
|
|
textures = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
|
|
textures = *textures_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsTextureEXT(UInt32 texture)
|
|
{
|
|
return Delegates.glIsTextureEXT((UInt32)texture);
|
|
}
|
|
|
|
public static
|
|
Boolean IsTextureEXT(Int32 texture)
|
|
{
|
|
return Delegates.glIsTextureEXT((UInt32)texture);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, UInt32* textures, Single* priorities)
|
|
{
|
|
unsafe { Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, Int32* textures, Single* priorities)
|
|
{
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, UInt32* textures, [In, Out] Single[] priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, Int32* textures, [In, Out] Single[] priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, UInt32* textures, ref Single priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, Int32* textures, ref Single priorities)
|
|
{
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, [In, Out] UInt32[] textures, Single* priorities)
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, [In, Out] Int32[] textures, Single* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, [In, Out] UInt32[] textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, [In, Out] Int32[] textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, [In, Out] UInt32[] textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, [In, Out] Int32[] textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, ref UInt32 textures, Single* priorities)
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PrioritizeTexturesEXT(Int32 n, ref Int32 textures, Single* priorities)
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, ref UInt32 textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, ref Int32 textures, [In, Out] Single[] priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, ref UInt32 textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PrioritizeTexturesEXT(Int32 n, ref Int32 textures, ref Single priorities)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* textures_ptr = &textures)
|
|
fixed (Single* priorities_ptr = &priorities)
|
|
{
|
|
Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ArrayElementEXT(Int32 i)
|
|
{
|
|
Delegates.glArrayElementEXT((Int32)i);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointerEXT(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, Int32 count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glColorPointerEXT((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (Int32)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointerEXT(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointerEXT((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (Int32)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawArraysEXT(GL.Enums.BeginMode mode, Int32 first, Int32 count)
|
|
{
|
|
Delegates.glDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointerEXT(Int32 stride, Int32 count, GL.Enums.Boolean* pointer)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (GL.Enums.Boolean*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPointervEXT(GL.Enums.GetPointervPName pname, [Out] void* @params)
|
|
{
|
|
unsafe { Delegates.glGetPointervEXT((GL.Enums.GetPointervPName)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPointervEXT(GL.Enums.GetPointervPName pname, [In, Out] 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 IndexPointerEXT(GL.Enums.IndexPointerType type, Int32 stride, Int32 count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glIndexPointerEXT((GL.Enums.IndexPointerType)type, (Int32)stride, (Int32)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointerEXT(GL.Enums.IndexPointerType type, Int32 stride, Int32 count, [In, Out] 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, (Int32)stride, (Int32)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointerEXT(GL.Enums.NormalPointerType type, Int32 stride, Int32 count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glNormalPointerEXT((GL.Enums.NormalPointerType)type, (Int32)stride, (Int32)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointerEXT(GL.Enums.NormalPointerType type, Int32 stride, Int32 count, [In, Out] 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, (Int32)stride, (Int32)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointerEXT(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, Int32 count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointerEXT((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (Int32)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointerEXT(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointerEXT((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (Int32)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointerEXT(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, Int32 count, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexPointerEXT((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (Int32)count, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointerEXT(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointerEXT((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (Int32)count, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendEquationEXT(GL.Enums.BlendEquationModeEXT mode)
|
|
{
|
|
Delegates.glBlendEquationEXT((GL.Enums.BlendEquationModeEXT)mode);
|
|
}
|
|
|
|
public static
|
|
void PointParameterfEXT(GL.Enums.EXT_point_parameters pname, Single param)
|
|
{
|
|
Delegates.glPointParameterfEXT((GL.Enums.EXT_point_parameters)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.EXT_point_parameters pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.EXT_point_parameters pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.EXT_point_parameters pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorSubTableEXT(GL.Enums.EXT_color_subtable target, Int32 start, Int32 count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
|
|
{
|
|
unsafe { Delegates.glColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (Int32)start, (Int32)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void ColorSubTableEXT(GL.Enums.EXT_color_subtable target, Int32 start, Int32 count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)start, (Int32)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorSubTableEXT(GL.Enums.EXT_color_subtable target, Int32 start, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableEXT(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelInternalFormat)internalFormat, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableEXT(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableEXT(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* data)
|
|
{
|
|
unsafe { Delegates.glGetColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableEXT(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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 GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void IndexMaterialEXT(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 IndexFuncEXT(GL.Enums.EXT_index_func func, Single @ref)
|
|
{
|
|
Delegates.glIndexFuncEXT((GL.Enums.EXT_index_func)func, (Single)@ref);
|
|
}
|
|
|
|
public static
|
|
void LockArraysEXT(Int32 first, Int32 count)
|
|
{
|
|
Delegates.glLockArraysEXT((Int32)first, (Int32)count);
|
|
}
|
|
|
|
public static
|
|
void UnlockArraysEXT()
|
|
{
|
|
Delegates.glUnlockArraysEXT();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CullParameterv(GL.Enums.EXT_cull_vertex pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (Double*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CullParameterv(GL.Enums.EXT_cull_vertex pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CullParameterv(GL.Enums.EXT_cull_vertex pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CullParameterv(GL.Enums.EXT_cull_vertex pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CullParameterv(GL.Enums.EXT_cull_vertex pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CullParameterv(GL.Enums.EXT_cull_vertex pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElementsEXT(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, GL.Enums.EXT_draw_range_elements type, void* indices)
|
|
{
|
|
unsafe { Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawRangeElementsEXT(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, GL.Enums.EXT_draw_range_elements type, void* indices)
|
|
{
|
|
{
|
|
Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElementsEXT(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, GL.Enums.EXT_draw_range_elements type, [In, Out] 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, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElementsEXT(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, GL.Enums.EXT_draw_range_elements type, [In, Out] 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, (UInt32)start, (UInt32)end, (Int32)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ApplyTextureEXT(GL.Enums.EXT_light_texture mode)
|
|
{
|
|
Delegates.glApplyTextureEXT((GL.Enums.EXT_light_texture)mode);
|
|
}
|
|
|
|
public static
|
|
void TextureLightEXT(GL.Enums.EXT_light_texture pname)
|
|
{
|
|
Delegates.glTextureLightEXT((GL.Enums.EXT_light_texture)pname);
|
|
}
|
|
|
|
public static
|
|
void TextureMaterialEXT(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
|
|
{
|
|
Delegates.glTextureMaterialEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameteriEXT(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, Int32 param)
|
|
{
|
|
Delegates.glPixelTransformParameteriEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterfEXT(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, Single param)
|
|
{
|
|
Delegates.glPixelTransformParameterfEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTransformParameterv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(SByte red, SByte green, SByte blue)
|
|
{
|
|
Delegates.glSecondaryColor3bEXT((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Byte red, Byte green, Byte blue)
|
|
{
|
|
Delegates.glSecondaryColor3bEXT((SByte)red, (SByte)green, (SByte)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3bvEXT((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Double red, Double green, Double blue)
|
|
{
|
|
Delegates.glSecondaryColor3dEXT((Double)red, (Double)green, (Double)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3dvEXT((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Single red, Single green, Single blue)
|
|
{
|
|
Delegates.glSecondaryColor3fEXT((Single)red, (Single)green, (Single)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3fvEXT((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Int32 red, Int32 green, Int32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3iEXT((Int32)red, (Int32)green, (Int32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3ivEXT((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3sEXT((Int16)red, (Int16)green, (Int16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3svEXT((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(UInt32 red, UInt32 green, UInt32 blue)
|
|
{
|
|
Delegates.glSecondaryColor3uiEXT((UInt32)red, (UInt32)green, (UInt32)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(UInt32* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3uivEXT((UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3(UInt16 red, UInt16 green, UInt16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3usEXT((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3v(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3usvEXT((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3v(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointerEXT(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointerEXT((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointerEXT(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointerEXT((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TextureNormalEXT(GL.Enums.EXT_texture_perturb_normal mode)
|
|
{
|
|
Delegates.glTextureNormalEXT((GL.Enums.EXT_texture_perturb_normal)mode);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] Int32* first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] Int32* first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
first = default(Int32*);
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] Int32* first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
first = default(Int32*);
|
|
count = default(Int32);
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
count = default(Int32*);
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] out Int32 first, [Out] Int32* count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
count = default(Int32*);
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] out Int32 first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
first = *first_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawArraysEXT(GL.Enums.BeginMode mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
|
|
{
|
|
first = default(Int32);
|
|
count = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
first = *first_ptr;
|
|
count = *count_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementsEXT(GL.Enums.BeginMode mode, Int32* count, GL.Enums.EXT_multi_draw_arrays type, void* indices, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (Int32*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementsEXT(GL.Enums.BeginMode mode, Int32* count, GL.Enums.EXT_multi_draw_arrays type, [In, Out] object indices, Int32 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, (Int32*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementsEXT(GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.EXT_multi_draw_arrays type, void* indices, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementsEXT(GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.EXT_multi_draw_arrays type, [In, Out] object indices, Int32 primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementsEXT(GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.EXT_multi_draw_arrays type, void* indices, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementsEXT(GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.EXT_multi_draw_arrays type, [In, Out] object indices, Int32 primcount)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (Int32*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordfEXT(Single coord)
|
|
{
|
|
Delegates.glFogCoordfEXT((Single)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordv(Single* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoordfvEXT((Single*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordv([In, Out] Single[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoordfvEXT((Single*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordv(ref Single coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoordfvEXT((Single*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoorddEXT(Double coord)
|
|
{
|
|
Delegates.glFogCoorddEXT((Double)coord);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordv(Double* coord)
|
|
{
|
|
unsafe { Delegates.glFogCoorddvEXT((Double*)coord); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordv([In, Out] Double[] coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coord_ptr = coord)
|
|
{
|
|
Delegates.glFogCoorddvEXT((Double*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordv(ref Double coord)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coord_ptr = &coord)
|
|
{
|
|
Delegates.glFogCoorddvEXT((Double*)coord_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointerEXT(GL.Enums.EXT_fog_coord type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointerEXT((GL.Enums.EXT_fog_coord)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointerEXT(GL.Enums.EXT_fog_coord type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3(SByte tx, SByte ty, SByte tz)
|
|
{
|
|
Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
|
|
}
|
|
|
|
public static
|
|
void Tangent3(Byte tx, Byte ty, Byte tz)
|
|
{
|
|
Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glTangent3bvEXT((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glTangent3bvEXT((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Tangent3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3(Double tx, Double ty, Double tz)
|
|
{
|
|
Delegates.glTangent3dEXT((Double)tx, (Double)ty, (Double)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glTangent3dvEXT((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3(Single tx, Single ty, Single tz)
|
|
{
|
|
Delegates.glTangent3fEXT((Single)tx, (Single)ty, (Single)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glTangent3fvEXT((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3(Int32 tx, Int32 ty, Int32 tz)
|
|
{
|
|
Delegates.glTangent3iEXT((Int32)tx, (Int32)ty, (Int32)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glTangent3ivEXT((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3(Int16 tx, Int16 ty, Int16 tz)
|
|
{
|
|
Delegates.glTangent3sEXT((Int16)tx, (Int16)ty, (Int16)tz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Tangent3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glTangent3svEXT((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Tangent3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTangent3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Tangent3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTangent3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3(SByte bx, SByte by, SByte bz)
|
|
{
|
|
Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
|
|
}
|
|
|
|
public static
|
|
void Binormal3(Byte bx, Byte by, Byte bz)
|
|
{
|
|
Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(SByte* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3bvEXT((SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(Byte* v)
|
|
{
|
|
{
|
|
Delegates.glBinormal3bvEXT((SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3v([In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v([In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Binormal3v(ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v(ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3bvEXT((SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3(Double bx, Double by, Double bz)
|
|
{
|
|
Delegates.glBinormal3dEXT((Double)bx, (Double)by, (Double)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3dvEXT((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3dvEXT((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3(Single bx, Single by, Single bz)
|
|
{
|
|
Delegates.glBinormal3fEXT((Single)bx, (Single)by, (Single)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3fvEXT((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3fvEXT((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3(Int32 bx, Int32 by, Int32 bz)
|
|
{
|
|
Delegates.glBinormal3iEXT((Int32)bx, (Int32)by, (Int32)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3ivEXT((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3ivEXT((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3(Int16 bx, Int16 by, Int16 bz)
|
|
{
|
|
Delegates.glBinormal3sEXT((Int16)bx, (Int16)by, (Int16)bz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Binormal3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glBinormal3svEXT((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void Binormal3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glBinormal3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Binormal3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glBinormal3svEXT((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TangentPointerEXT(GL.Enums.EXT_coordinate_frame type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glTangentPointerEXT((GL.Enums.EXT_coordinate_frame)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void TangentPointerEXT(GL.Enums.EXT_coordinate_frame type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void BinormalPointerEXT(GL.Enums.EXT_coordinate_frame type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glBinormalPointerEXT((GL.Enums.EXT_coordinate_frame)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void BinormalPointerEXT(GL.Enums.EXT_coordinate_frame type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BlendFuncSeparateEXT(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 VertexWeightfEXT(Single weight)
|
|
{
|
|
Delegates.glVertexWeightfEXT((Single)weight);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeightv(Single* weight)
|
|
{
|
|
unsafe { Delegates.glVertexWeightfvEXT((Single*)weight); }
|
|
}
|
|
|
|
public static
|
|
void VertexWeightv([In, Out] Single[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeightv(ref Single weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeightPointerEXT(Int32 size, GL.Enums.EXT_vertex_weighting type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexWeightPointerEXT((Int32)size, (GL.Enums.EXT_vertex_weighting)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexWeightPointerEXT(Int32 size, GL.Enums.EXT_vertex_weighting type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexWeightPointerEXT((Int32)size, (GL.Enums.EXT_vertex_weighting)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleMaskEXT(Single value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleMaskEXT((Single)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
public static
|
|
void SamplePatternEXT(GL.Enums.EXT_multisample pattern)
|
|
{
|
|
Delegates.glSamplePatternEXT((GL.Enums.EXT_multisample)pattern);
|
|
}
|
|
|
|
public static
|
|
void BeginVertexShaderEXT()
|
|
{
|
|
Delegates.glBeginVertexShaderEXT();
|
|
}
|
|
|
|
public static
|
|
void EndVertexShaderEXT()
|
|
{
|
|
Delegates.glEndVertexShaderEXT();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindVertexShaderEXT(UInt32 id)
|
|
{
|
|
Delegates.glBindVertexShaderEXT((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BindVertexShaderEXT(Int32 id)
|
|
{
|
|
Delegates.glBindVertexShaderEXT((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenVertexShadersEXT(UInt32 range)
|
|
{
|
|
return Delegates.glGenVertexShadersEXT((UInt32)range);
|
|
}
|
|
|
|
public static
|
|
Int32 GenVertexShadersEXT(Int32 range)
|
|
{
|
|
return Delegates.glGenVertexShadersEXT((UInt32)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexShaderEXT(UInt32 id)
|
|
{
|
|
Delegates.glDeleteVertexShaderEXT((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexShaderEXT(Int32 id)
|
|
{
|
|
Delegates.glDeleteVertexShaderEXT((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp1EXT(GL.Enums.EXT_vertex_shader op, UInt32 res, UInt32 arg1)
|
|
{
|
|
Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp1EXT(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1)
|
|
{
|
|
Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp2EXT(GL.Enums.EXT_vertex_shader op, UInt32 res, UInt32 arg1, UInt32 arg2)
|
|
{
|
|
Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp2EXT(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2)
|
|
{
|
|
Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ShaderOp3EXT(GL.Enums.EXT_vertex_shader op, UInt32 res, UInt32 arg1, UInt32 arg2, UInt32 arg3)
|
|
{
|
|
Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
|
|
}
|
|
|
|
public static
|
|
void ShaderOp3EXT(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2, Int32 arg3)
|
|
{
|
|
Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SwizzleEXT(UInt32 res, UInt32 @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((UInt32)res, (UInt32)@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 SwizzleEXT(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((UInt32)res, (UInt32)@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 WriteMaskEXT(UInt32 res, UInt32 @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((UInt32)res, (UInt32)@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 WriteMaskEXT(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((UInt32)res, (UInt32)@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 InsertComponentEXT(UInt32 res, UInt32 src, UInt32 num)
|
|
{
|
|
Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
|
|
}
|
|
|
|
public static
|
|
void InsertComponentEXT(Int32 res, Int32 src, Int32 num)
|
|
{
|
|
Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExtractComponentEXT(UInt32 res, UInt32 src, UInt32 num)
|
|
{
|
|
Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
|
|
}
|
|
|
|
public static
|
|
void ExtractComponentEXT(Int32 res, Int32 src, Int32 num)
|
|
{
|
|
Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenSymbolsEXT(GL.Enums.EXT_vertex_shader datatype, GL.Enums.EXT_vertex_shader storagetype, GL.Enums.EXT_vertex_shader range, UInt32 components)
|
|
{
|
|
return Delegates.glGenSymbolsEXT((GL.Enums.EXT_vertex_shader)datatype, (GL.Enums.EXT_vertex_shader)storagetype, (GL.Enums.EXT_vertex_shader)range, (UInt32)components);
|
|
}
|
|
|
|
public static
|
|
Int32 GenSymbolsEXT(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, (UInt32)components);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetInvariantEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
unsafe { Delegates.glSetInvariantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetInvariantEXT(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
{
|
|
Delegates.glSetInvariantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetInvariantEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetInvariantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetInvariantEXT(Int32 id, GL.Enums.EXT_vertex_shader type, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetInvariantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetLocalConstantEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
unsafe { Delegates.glSetLocalConstantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetLocalConstantEXT(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
|
|
{
|
|
{
|
|
Delegates.glSetLocalConstantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetLocalConstantEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetLocalConstantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetLocalConstantEXT(Int32 id, GL.Enums.EXT_vertex_shader type, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSetLocalConstantEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, SByte* addr)
|
|
{
|
|
unsafe { Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(Int32 id, Byte* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] SByte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, [In, Out] Byte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref SByte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, ref Byte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, Int16* addr)
|
|
{
|
|
unsafe { Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(Int32 id, Int16* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] Int16[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, [In, Out] Int16[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref Int16 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, ref Int16 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, Int32* addr)
|
|
{
|
|
unsafe { Delegates.glVariantivEXT((UInt32)id, (Int32*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(Int32 id, Int32* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantivEXT((UInt32)id, (Int32*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] Int32[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, [In, Out] Int32[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref Int32 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, ref Int32 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, Single* addr)
|
|
{
|
|
unsafe { Delegates.glVariantfvEXT((UInt32)id, (Single*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(Int32 id, Single* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantfvEXT((UInt32)id, (Single*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] Single[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, [In, Out] Single[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref Single addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, ref Single addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, Double* addr)
|
|
{
|
|
unsafe { Delegates.glVariantdvEXT((UInt32)id, (Double*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(Int32 id, Double* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantdvEXT((UInt32)id, (Double*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] Double[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, [In, Out] Double[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref Double addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Variantv(Int32 id, ref Double addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, Byte* addr)
|
|
{
|
|
unsafe { Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] Byte[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref Byte addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, UInt16* addr)
|
|
{
|
|
unsafe { Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] UInt16[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref UInt16 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Variantv(UInt32 id, UInt32* addr)
|
|
{
|
|
unsafe { Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, [In, Out] UInt32[] addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* addr_ptr = addr)
|
|
{
|
|
Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Variantv(UInt32 id, ref UInt32 addr)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* addr_ptr = &addr)
|
|
{
|
|
Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VariantPointerEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, UInt32 stride, void* addr)
|
|
{
|
|
unsafe { Delegates.glVariantPointerEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (UInt32)stride, (void*)addr); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VariantPointerEXT(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, void* addr)
|
|
{
|
|
{
|
|
Delegates.glVariantPointerEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (UInt32)stride, (void*)addr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VariantPointerEXT(UInt32 id, GL.Enums.EXT_vertex_shader type, UInt32 stride, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVariantPointerEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (UInt32)stride, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VariantPointerEXT(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, [In, Out] object addr)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVariantPointerEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)type, (UInt32)stride, (void*)addr_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
addr_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableVariantClientStateEXT(UInt32 id)
|
|
{
|
|
Delegates.glEnableVariantClientStateEXT((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void EnableVariantClientStateEXT(Int32 id)
|
|
{
|
|
Delegates.glEnableVariantClientStateEXT((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableVariantClientStateEXT(UInt32 id)
|
|
{
|
|
Delegates.glDisableVariantClientStateEXT((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void DisableVariantClientStateEXT(Int32 id)
|
|
{
|
|
Delegates.glDisableVariantClientStateEXT((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
Int32 BindLightParameterEXT(GL.Enums.LightName light, GL.Enums.LightParameter value)
|
|
{
|
|
return Delegates.glBindLightParameterEXT((GL.Enums.LightName)light, (GL.Enums.LightParameter)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindMaterialParameterEXT(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter value)
|
|
{
|
|
return Delegates.glBindMaterialParameterEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)value);
|
|
}
|
|
|
|
public static
|
|
Int32 BindTexGenParameterEXT(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 BindTextureUnitParameterEXT(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 BindParameterEXT(GL.Enums.EXT_vertex_shader value)
|
|
{
|
|
return Delegates.glBindParameterEXT((GL.Enums.EXT_vertex_shader)value);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsVariantEnabledEXT(UInt32 id, GL.Enums.EXT_vertex_shader cap)
|
|
{
|
|
return Delegates.glIsVariantEnabledEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)cap);
|
|
}
|
|
|
|
public static
|
|
Boolean IsVariantEnabledEXT(Int32 id, GL.Enums.EXT_vertex_shader cap)
|
|
{
|
|
return Delegates.glIsVariantEnabledEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)cap);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantBooleanvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantBooleanvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetVariantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
data = default(Int32*);
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
data = default(Single*);
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetVariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantPointervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] void* data)
|
|
{
|
|
unsafe { Delegates.glGetVariantPointervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (void*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantPointervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] void* data)
|
|
{
|
|
data = default(void*);
|
|
{
|
|
Delegates.glGetVariantPointervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (void*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantPointervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVariantPointervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantPointervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] object data)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVariantPointervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
data_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantBooleanvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantBooleanvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetInvariantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
data = default(Int32*);
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
unsafe { Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetInvariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
data = default(Single*);
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetInvariantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetInvariantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetInvariantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantBooleanvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantBooleanvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Int32* data)
|
|
{
|
|
data = default(Int32*);
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantIntegervEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantIntegervEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
unsafe { Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetLocalConstantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] Single* data)
|
|
{
|
|
data = default(Single*);
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [In, Out] Single[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetLocalConstantFloatvEXT(UInt32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetLocalConstantFloatvEXT(Int32 id, GL.Enums.EXT_vertex_shader value, [Out] out Single data)
|
|
{
|
|
data = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* data_ptr = &data)
|
|
{
|
|
Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (GL.Enums.EXT_vertex_shader)value, (Single*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ActiveStencilFaceEXT(GL.Enums.EXT_stencil_two_side face)
|
|
{
|
|
Delegates.glActiveStencilFaceEXT((GL.Enums.EXT_stencil_two_side)face);
|
|
}
|
|
|
|
public static
|
|
void DepthBoundsEXT(Double zmin, Double zmax)
|
|
{
|
|
Delegates.glDepthBoundsEXT((Double)zmin, (Double)zmax);
|
|
}
|
|
|
|
public static
|
|
void BlendEquationSeparateEXT(GL.Enums.BlendEquationModeEXT modeRGB, GL.Enums.BlendEquationModeEXT modeAlpha)
|
|
{
|
|
Delegates.glBlendEquationSeparateEXT((GL.Enums.BlendEquationModeEXT)modeRGB, (GL.Enums.BlendEquationModeEXT)modeAlpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsRenderbufferEXT(UInt32 renderbuffer)
|
|
{
|
|
return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
|
|
}
|
|
|
|
public static
|
|
Boolean IsRenderbufferEXT(Int32 renderbuffer)
|
|
{
|
|
return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindRenderbufferEXT(GL.Enums.EXT_framebuffer_object target, UInt32 renderbuffer)
|
|
{
|
|
Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (UInt32)renderbuffer);
|
|
}
|
|
|
|
public static
|
|
void BindRenderbufferEXT(GL.Enums.EXT_framebuffer_object target, Int32 renderbuffer)
|
|
{
|
|
Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (UInt32)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteRenderbuffersEXT(Int32 n, UInt32* renderbuffers)
|
|
{
|
|
unsafe { Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteRenderbuffersEXT(Int32 n, Int32* renderbuffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteRenderbuffersEXT(Int32 n, [In, Out] UInt32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteRenderbuffersEXT(Int32 n, [In, Out] Int32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteRenderbuffersEXT(Int32 n, ref UInt32 renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteRenderbuffersEXT(Int32 n, ref Int32 renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenRenderbuffersEXT(Int32 n, [Out] UInt32* renderbuffers)
|
|
{
|
|
unsafe { Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenRenderbuffersEXT(Int32 n, [Out] Int32* renderbuffers)
|
|
{
|
|
renderbuffers = default(Int32*);
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenRenderbuffersEXT(Int32 n, [In, Out] UInt32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenRenderbuffersEXT(Int32 n, [In, Out] Int32[] renderbuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenRenderbuffersEXT(Int32 n, [Out] out UInt32 renderbuffers)
|
|
{
|
|
renderbuffers = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
renderbuffers = *renderbuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenRenderbuffersEXT(Int32 n, [Out] out Int32 renderbuffers)
|
|
{
|
|
renderbuffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* renderbuffers_ptr = &renderbuffers)
|
|
{
|
|
Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
|
|
renderbuffers = *renderbuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorageEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object internalformat, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glRenderbufferStorageEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)internalformat, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetRenderbufferParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetRenderbufferParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetRenderbufferParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsFramebufferEXT(UInt32 framebuffer)
|
|
{
|
|
return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
|
|
}
|
|
|
|
public static
|
|
Boolean IsFramebufferEXT(Int32 framebuffer)
|
|
{
|
|
return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFramebufferEXT(GL.Enums.EXT_framebuffer_object target, UInt32 framebuffer)
|
|
{
|
|
Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (UInt32)framebuffer);
|
|
}
|
|
|
|
public static
|
|
void BindFramebufferEXT(GL.Enums.EXT_framebuffer_object target, Int32 framebuffer)
|
|
{
|
|
Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (UInt32)framebuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFramebuffersEXT(Int32 n, UInt32* framebuffers)
|
|
{
|
|
unsafe { Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFramebuffersEXT(Int32 n, Int32* framebuffers)
|
|
{
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFramebuffersEXT(Int32 n, [In, Out] UInt32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFramebuffersEXT(Int32 n, [In, Out] Int32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFramebuffersEXT(Int32 n, ref UInt32 framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFramebuffersEXT(Int32 n, ref Int32 framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFramebuffersEXT(Int32 n, [Out] UInt32* framebuffers)
|
|
{
|
|
unsafe { Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFramebuffersEXT(Int32 n, [Out] Int32* framebuffers)
|
|
{
|
|
framebuffers = default(Int32*);
|
|
{
|
|
Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFramebuffersEXT(Int32 n, [In, Out] UInt32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFramebuffersEXT(Int32 n, [In, Out] Int32[] framebuffers)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFramebuffersEXT(Int32 n, [Out] out UInt32 framebuffers)
|
|
{
|
|
framebuffers = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
framebuffers = *framebuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFramebuffersEXT(Int32 n, [Out] out Int32 framebuffers)
|
|
{
|
|
framebuffers = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* framebuffers_ptr = &framebuffers)
|
|
{
|
|
Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
|
|
framebuffers = *framebuffers_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
GL.Enums.All CheckFramebufferStat(GL.Enums.EXT_framebuffer_object target)
|
|
{
|
|
return Delegates.glCheckFramebufferStatusEXT((GL.Enums.EXT_framebuffer_object)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture1DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, UInt32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture1DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture2DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, UInt32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture2DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTexture3DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, UInt32 texture, Int32 level, Int32 zoffset)
|
|
{
|
|
Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTexture3DEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, Int32 level, Int32 zoffset)
|
|
{
|
|
Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferRenderbufferEXT(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object renderbuffertarget, UInt32 renderbuffer)
|
|
{
|
|
Delegates.glFramebufferRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)renderbuffertarget, (UInt32)renderbuffer);
|
|
}
|
|
|
|
public static
|
|
void FramebufferRenderbufferEXT(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, (UInt32)renderbuffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFramebufferAttachmentParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFramebufferAttachmentParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFramebufferAttachmentParameterv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenerateMipmapEXT(GL.Enums.EXT_framebuffer_object target)
|
|
{
|
|
Delegates.glGenerateMipmapEXT((GL.Enums.EXT_framebuffer_object)target);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilClearTagEXT(Int32 stencilTagBits, UInt32 stencilClearTag)
|
|
{
|
|
Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
|
|
}
|
|
|
|
public static
|
|
void StencilClearTagEXT(Int32 stencilTagBits, Int32 stencilClearTag)
|
|
{
|
|
Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
|
|
}
|
|
|
|
public static
|
|
void BlitFramebufferEXT(Int32 srcX0, Int32 srcY0, Int32 srcX1, Int32 srcY1, Int32 dstX0, Int32 dstY0, Int32 dstX1, Int32 dstY1, GL.Enums.ClearBufferMask mask, GL.Enums.EXT_framebuffer_blit filter)
|
|
{
|
|
Delegates.glBlitFramebufferEXT((Int32)srcX0, (Int32)srcY0, (Int32)srcX1, (Int32)srcY1, (Int32)dstX0, (Int32)dstY0, (Int32)dstX1, (Int32)dstY1, (GL.Enums.ClearBufferMask)mask, (GL.Enums.EXT_framebuffer_blit)filter);
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorageMultisampleEXT(GL.Enums.EXT_framebuffer_multisample target, Int32 samples, GL.Enums.EXT_framebuffer_multisample internalformat, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glRenderbufferStorageMultisampleEXT((GL.Enums.EXT_framebuffer_multisample)target, (Int32)samples, (GL.Enums.EXT_framebuffer_multisample)internalformat, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjecti64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [Out] Int64* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjecti64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [Out] Int64* @params)
|
|
{
|
|
@params = default(Int64*);
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjecti64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [In, Out] Int64[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjecti64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [In, Out] Int64[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjecti64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [Out] out Int64 @params)
|
|
{
|
|
@params = default(Int64);
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjecti64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [Out] out Int64 @params)
|
|
{
|
|
@params = default(Int64);
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjecti64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (Int64*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectui64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [Out] UInt64* @params)
|
|
{
|
|
unsafe { Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetQueryObjectui64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [Out] Int64* @params)
|
|
{
|
|
@params = default(Int64*);
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectui64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [In, Out] UInt64[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt64* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectui64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [In, Out] Int64[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetQueryObjectui64vEXT(UInt32 id, GL.Enums.EXT_timer_query pname, [Out] out UInt64 @params)
|
|
{
|
|
@params = default(UInt64);
|
|
unsafe
|
|
{
|
|
fixed (UInt64* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetQueryObjectui64vEXT(Int32 id, GL.Enums.EXT_timer_query pname, [Out] out Int64 @params)
|
|
{
|
|
@params = default(Int64);
|
|
unsafe
|
|
{
|
|
fixed (Int64* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetQueryObjectui64vEXT((UInt32)id, (GL.Enums.EXT_timer_query)pname, (UInt64*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, Single* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, Single* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, UInt32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameters4v(GL.Enums.EXT_gpu_program_parameters target, Int32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTextureEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, UInt32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTextureEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, Int32 level)
|
|
{
|
|
Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTextureLayerEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, UInt32 texture, Int32 level, Int32 layer)
|
|
{
|
|
Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTextureLayerEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, Int32 level, Int32 layer)
|
|
{
|
|
Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FramebufferTextureFaceEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, UInt32 texture, Int32 level, GL.Enums.TextureTarget face)
|
|
{
|
|
Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level, (GL.Enums.TextureTarget)face);
|
|
}
|
|
|
|
public static
|
|
void FramebufferTextureFaceEXT(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, Int32 level, GL.Enums.TextureTarget face)
|
|
{
|
|
Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (UInt32)texture, (Int32)level, (GL.Enums.TextureTarget)face);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameteriEXT(UInt32 program, GL.Enums.EXT_geometry_shader4 pname, Int32 value)
|
|
{
|
|
Delegates.glProgramParameteriEXT((UInt32)program, (GL.Enums.EXT_geometry_shader4)pname, (Int32)value);
|
|
}
|
|
|
|
public static
|
|
void ProgramParameteriEXT(Int32 program, GL.Enums.EXT_geometry_shader4 pname, Int32 value)
|
|
{
|
|
Delegates.glProgramParameteriEXT((UInt32)program, (GL.Enums.EXT_geometry_shader4)pname, (Int32)value);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1(UInt32 index, Int32 x)
|
|
{
|
|
Delegates.glVertexAttribI1iEXT((UInt32)index, (Int32)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1(Int32 index, Int32 x)
|
|
{
|
|
Delegates.glVertexAttribI1iEXT((UInt32)index, (Int32)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2(UInt32 index, Int32 x, Int32 y)
|
|
{
|
|
Delegates.glVertexAttribI2iEXT((UInt32)index, (Int32)x, (Int32)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2(Int32 index, Int32 x, Int32 y)
|
|
{
|
|
Delegates.glVertexAttribI2iEXT((UInt32)index, (Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3(UInt32 index, Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glVertexAttribI3iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3(Int32 index, Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glVertexAttribI3iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4(UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glVertexAttribI4iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glVertexAttribI4iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1(UInt32 index, UInt32 x)
|
|
{
|
|
Delegates.glVertexAttribI1uiEXT((UInt32)index, (UInt32)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2(UInt32 index, UInt32 x, UInt32 y)
|
|
{
|
|
Delegates.glVertexAttribI2uiEXT((UInt32)index, (UInt32)x, (UInt32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3(UInt32 index, UInt32 x, UInt32 y, UInt32 z)
|
|
{
|
|
Delegates.glVertexAttribI3uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4(UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
|
|
{
|
|
Delegates.glVertexAttribI4uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI1v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI2v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI3v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, Int32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(Int32 index, Int32* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, [In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI1v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI1v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI2v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI2v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI3v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI3v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, UInt32* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] UInt32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref UInt32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, SByte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] SByte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref SByte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribI4v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribI4v(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribI4v(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribIPointerEXT(UInt32 index, Int32 size, GL.Enums.NV_vertex_program4 type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (GL.Enums.NV_vertex_program4)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribIPointerEXT(Int32 index, Int32 size, GL.Enums.NV_vertex_program4 type, Int32 stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (GL.Enums.NV_vertex_program4)type, (Int32)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribIPointerEXT(UInt32 index, Int32 size, GL.Enums.NV_vertex_program4 type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (GL.Enums.NV_vertex_program4)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribIPointerEXT(Int32 index, Int32 size, GL.Enums.NV_vertex_program4 type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (GL.Enums.NV_vertex_program4)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIv(Int32 index, GL.Enums.NV_vertex_program4 pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIv(Int32 index, GL.Enums.NV_vertex_program4 pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribIv(Int32 index, GL.Enums.NV_vertex_program4 pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribIuivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribIv(UInt32 index, GL.Enums.NV_vertex_program4 pname, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribIuivEXT((UInt32)index, (GL.Enums.NV_vertex_program4)pname, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(UInt32 program, Int32 location, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetUniformv(Int32 program, Int32 location, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetUniformv(UInt32 program, Int32 location, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetUniformv(Int32 program, Int32 location, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFragDataLocationEXT(UInt32 program, UInt32 color, System.String name)
|
|
{
|
|
Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void BindFragDataLocationEXT(Int32 program, Int32 color, System.String name)
|
|
{
|
|
Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetFragDataLocationEXT(UInt32 program, System.String name)
|
|
{
|
|
return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetFragDataLocationEXT(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1(Int32 location, UInt32 v0)
|
|
{
|
|
Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
|
|
}
|
|
|
|
public static
|
|
void Uniform1(Int32 location, Int32 v0)
|
|
{
|
|
Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2(Int32 location, UInt32 v0, UInt32 v1)
|
|
{
|
|
Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
|
|
}
|
|
|
|
public static
|
|
void Uniform2(Int32 location, Int32 v0, Int32 v1)
|
|
{
|
|
Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
|
|
{
|
|
Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
|
|
}
|
|
|
|
public static
|
|
void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
|
|
{
|
|
Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
|
|
{
|
|
Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
|
|
}
|
|
|
|
public static
|
|
void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
|
|
{
|
|
Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, UInt32* value)
|
|
{
|
|
unsafe { Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform1v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] UInt32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref UInt32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform1v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, UInt32* value)
|
|
{
|
|
unsafe { Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] UInt32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref UInt32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform2v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, UInt32* value)
|
|
{
|
|
unsafe { Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform3v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] UInt32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref UInt32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform3v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, UInt32* value)
|
|
{
|
|
unsafe { Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Uniform4v(Int32 location, Int32 count, Int32* value)
|
|
{
|
|
{
|
|
Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] UInt32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, [In, Out] Int32[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = value)
|
|
{
|
|
Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref UInt32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Uniform4v(Int32 location, Int32 count, ref Int32 value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* value_ptr = &value)
|
|
{
|
|
Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawArraysInstancedEXT(GL.Enums.BeginMode mode, Int32 start, Int32 count, Int32 primcount)
|
|
{
|
|
Delegates.glDrawArraysInstancedEXT((GL.Enums.BeginMode)mode, (Int32)start, (Int32)count, (Int32)primcount);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawElementsInstancedEXT(GL.Enums.BeginMode mode, Int32 count, GL.Enums.EXT_draw_instanced type, void* indices, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glDrawElementsInstancedEXT((GL.Enums.BeginMode)mode, (Int32)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices, (Int32)primcount); }
|
|
}
|
|
|
|
public static
|
|
void DrawElementsInstancedEXT(GL.Enums.BeginMode mode, Int32 count, GL.Enums.EXT_draw_instanced type, [In, Out] object indices, Int32 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, (Int32)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexBufferEXT(GL.Enums.TextureTarget target, GL.Enums.EXT_texture_buffer_object internalformat, UInt32 buffer)
|
|
{
|
|
Delegates.glTexBufferEXT((GL.Enums.TextureTarget)target, (GL.Enums.EXT_texture_buffer_object)internalformat, (UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void TexBufferEXT(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, (UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorMaskIndexedEXT(UInt32 index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
|
|
{
|
|
Delegates.glColorMaskIndexedEXT((UInt32)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a);
|
|
}
|
|
|
|
public static
|
|
void ColorMaskIndexedEXT(Int32 index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glColorMaskIndexedEXT((UInt32)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBooleanIndexev(GL.Enums.EXT_draw_buffers2 target, UInt32 index, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
unsafe { Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (GL.Enums.Boolean*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetBooleanIndexev(GL.Enums.EXT_draw_buffers2 target, Int32 index, [Out] GL.Enums.Boolean* data)
|
|
{
|
|
data = default(GL.Enums.Boolean*);
|
|
{
|
|
Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (GL.Enums.Boolean*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, UInt32 index, [Out] Int32* data)
|
|
{
|
|
unsafe { Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, Int32 index, [Out] Int32* data)
|
|
{
|
|
data = default(Int32*);
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, UInt32 index, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, Int32 index, [In, Out] Int32[] data)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, UInt32 index, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetIntegerIndexev(GL.Enums.EXT_draw_buffers2 target, Int32 index, [Out] out Int32 data)
|
|
{
|
|
data = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* data_ptr = &data)
|
|
{
|
|
Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index, (Int32*)data_ptr);
|
|
data = *data_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void EnableIndexedEXT(GL.Enums.EXT_draw_buffers2 target, UInt32 index)
|
|
{
|
|
Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void EnableIndexedEXT(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DisableIndexedEXT(GL.Enums.EXT_draw_buffers2 target, UInt32 index)
|
|
{
|
|
Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void DisableIndexedEXT(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsEnabledIndexedEXT(GL.Enums.EXT_draw_buffers2 target, UInt32 index)
|
|
{
|
|
return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
public static
|
|
Boolean IsEnabledIndexedEXT(GL.Enums.EXT_draw_buffers2 target, Int32 index)
|
|
{
|
|
return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UniformBufferEXT(UInt32 program, Int32 location, UInt32 buffer)
|
|
{
|
|
Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void UniformBufferEXT(Int32 program, Int32 location, Int32 buffer)
|
|
{
|
|
Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetUniformBufferSizeEXT(UInt32 program, Int32 location)
|
|
{
|
|
return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
|
|
}
|
|
|
|
public static
|
|
Int32 GetUniformBufferSizeEXT(Int32 program, Int32 location)
|
|
{
|
|
return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
IntPtr GetUniformOffsetEXT(UInt32 program, Int32 location)
|
|
{
|
|
return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
|
|
}
|
|
|
|
public static
|
|
IntPtr GetUniformOffsetEXT(Int32 program, Int32 location)
|
|
{
|
|
return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexParameterIv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTexParameterIv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClearColorIiEXT(Int32 red, Int32 green, Int32 blue, Int32 alpha)
|
|
{
|
|
Delegates.glClearColorIiEXT((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ClearColorI(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
|
|
{
|
|
Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
|
|
}
|
|
|
|
public static
|
|
void ClearColorI(Int32 red, Int32 green, Int32 blue, Int32 alpha)
|
|
{
|
|
Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
|
|
}
|
|
|
|
}
|
|
|
|
public static class SGIS
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, [Out] Single* weights)
|
|
{
|
|
unsafe { Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Single*)weights); }
|
|
}
|
|
|
|
public static
|
|
void GetTexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, [In, Out] Single[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = weights)
|
|
{
|
|
Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Single*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, [Out] out Single weights)
|
|
{
|
|
weights = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = &weights)
|
|
{
|
|
Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Single*)weights_ptr);
|
|
weights = *weights_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, Int32 n, Single* weights)
|
|
{
|
|
unsafe { Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Int32)n, (Single*)weights); }
|
|
}
|
|
|
|
public static
|
|
void TexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, Int32 n, [In, Out] Single[] weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = weights)
|
|
{
|
|
Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Int32)n, (Single*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexFilterFuncSGIS(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, Int32 n, ref Single weights)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* weights_ptr = &weights)
|
|
{
|
|
Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (Int32)n, (Single*)weights_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameteriSGIS(GL.Enums.PixelTexGenParameterNameSGIS pname, Int32 param)
|
|
{
|
|
Delegates.glPixelTexGenParameteriSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterfSGIS(GL.Enums.PixelTexGenParameterNameSGIS pname, Single param)
|
|
{
|
|
Delegates.glPixelTexGenParameterfSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetPixelTexGenParameterv(GL.Enums.PixelTexGenParameterNameSGIS pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexImage4DSGIS(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexImage4DSGIS((GL.Enums.TextureTarget)target, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexImage4DSGIS(GL.Enums.TextureTarget target, Int32 level, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexSubImage4DSGIS(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
|
|
{
|
|
unsafe { Delegates.glTexSubImage4DSGIS((GL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
|
|
}
|
|
|
|
public static
|
|
void TexSubImage4DSGIS(GL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pixels_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DetailTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, Single* points)
|
|
{
|
|
unsafe { Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void DetailTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DetailTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetDetailTexFuncSGIS(GL.Enums.TextureTarget target, [Out] Single* points)
|
|
{
|
|
unsafe { Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetDetailTexFuncSGIS(GL.Enums.TextureTarget target, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetDetailTexFuncSGIS(GL.Enums.TextureTarget target, [Out] out Single points)
|
|
{
|
|
points = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SharpenTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, Single* points)
|
|
{
|
|
unsafe { Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void SharpenTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SharpenTexFuncSGIS(GL.Enums.TextureTarget target, Int32 n, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetSharpenTexFuncSGIS(GL.Enums.TextureTarget target, [Out] Single* points)
|
|
{
|
|
unsafe { Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetSharpenTexFuncSGIS(GL.Enums.TextureTarget target, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetSharpenTexFuncSGIS(GL.Enums.TextureTarget target, [Out] out Single points)
|
|
{
|
|
points = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (Single*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SampleMaskSGIS(Single value, GL.Enums.Boolean invert)
|
|
{
|
|
Delegates.glSampleMaskSGIS((Single)value, (GL.Enums.Boolean)invert);
|
|
}
|
|
|
|
public static
|
|
void SamplePatternSGIS(GL.Enums.SamplePatternSGIS pattern)
|
|
{
|
|
Delegates.glSamplePatternSGIS((GL.Enums.SamplePatternSGIS)pattern);
|
|
}
|
|
|
|
public static
|
|
void PointParameterfSGIS(GL.Enums.SGIS_point_parameters pname, Single param)
|
|
{
|
|
Delegates.glPointParameterfSGIS((GL.Enums.SGIS_point_parameters)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.SGIS_point_parameters pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.SGIS_point_parameters pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.SGIS_point_parameters pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogFuncSGIS(Int32 n, Single* points)
|
|
{
|
|
unsafe { Delegates.glFogFuncSGIS((Int32)n, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void FogFuncSGIS(Int32 n, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogFuncSGIS(Int32 n, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFogFuncSGIS([Out] Single* points)
|
|
{
|
|
unsafe { Delegates.glGetFogFuncSGIS((Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void GetFogFuncSGIS([In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glGetFogFuncSGIS((Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFogFuncSGIS([Out] out Single points)
|
|
{
|
|
points = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glGetFogFuncSGIS((Single*)points_ptr);
|
|
points = *points_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TextureColorMaskSGIS(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 ColorTableSGI(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
|
|
{
|
|
unsafe { Delegates.glColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableSGI(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, Int32 width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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, (Int32)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
table_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CopyColorTableSGI(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
|
|
{
|
|
Delegates.glCopyColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableSGI(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [Out] void* table)
|
|
{
|
|
unsafe { Delegates.glGetColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableSGI(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, [In, Out] 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 GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetColorTableParameterv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class SGIX
|
|
{
|
|
public static
|
|
void PixelTexGenSGIX(GL.Enums.SGIX_pixel_texture mode)
|
|
{
|
|
Delegates.glPixelTexGenSGIX((GL.Enums.SGIX_pixel_texture)mode);
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterfSGIX(GL.Enums.SGIX_sprite pname, Single param)
|
|
{
|
|
Delegates.glSpriteParameterfSGIX((GL.Enums.SGIX_sprite)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SpriteParameterv(GL.Enums.SGIX_sprite pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterv(GL.Enums.SGIX_sprite pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterv(GL.Enums.SGIX_sprite pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameteriSGIX(GL.Enums.SGIX_sprite pname, Int32 param)
|
|
{
|
|
Delegates.glSpriteParameteriSGIX((GL.Enums.SGIX_sprite)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SpriteParameterv(GL.Enums.SGIX_sprite pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterv(GL.Enums.SGIX_sprite pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SpriteParameterv(GL.Enums.SGIX_sprite pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 GetInstrumentsSGIX()
|
|
{
|
|
return Delegates.glGetInstrumentsSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void InstrumentsBufferSGIX(Int32 size, [Out] Int32* buffer)
|
|
{
|
|
unsafe { Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer); }
|
|
}
|
|
|
|
public static
|
|
void InstrumentsBufferSGIX(Int32 size, [In, Out] Int32[] buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = buffer)
|
|
{
|
|
Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void InstrumentsBufferSGIX(Int32 size, [Out] out Int32 buffer)
|
|
{
|
|
buffer = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* buffer_ptr = &buffer)
|
|
{
|
|
Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
|
|
buffer = *buffer_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 PollInstrumentsSGIX([Out] Int32* marker_p)
|
|
{
|
|
unsafe { return Delegates.glPollInstrumentsSGIX((Int32*)marker_p); }
|
|
}
|
|
|
|
public static
|
|
Int32 PollInstrumentsSGIX([In, Out] Int32[] marker_p)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* marker_p_ptr = marker_p)
|
|
{
|
|
Int32 retval = Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 PollInstrumentsSGIX([Out] out Int32 marker_p)
|
|
{
|
|
marker_p = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* marker_p_ptr = &marker_p)
|
|
{
|
|
Int32 retval = Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
|
|
marker_p = *marker_p_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReadInstrumentsSGIX(Int32 marker)
|
|
{
|
|
Delegates.glReadInstrumentsSGIX((Int32)marker);
|
|
}
|
|
|
|
public static
|
|
void StartInstrumentsSGIX()
|
|
{
|
|
Delegates.glStartInstrumentsSGIX();
|
|
}
|
|
|
|
public static
|
|
void StopInstrumentsSGIX(Int32 marker)
|
|
{
|
|
Delegates.glStopInstrumentsSGIX((Int32)marker);
|
|
}
|
|
|
|
public static
|
|
void FrameZoomSGIX(Int32 factor)
|
|
{
|
|
Delegates.glFrameZoomSGIX((Int32)factor);
|
|
}
|
|
|
|
public static
|
|
void TagSampleBufferSGIX()
|
|
{
|
|
Delegates.glTagSampleBufferSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeformationMap3(GL.Enums.FfdTargetSGIX target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, Double* points)
|
|
{
|
|
unsafe { Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points); }
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3(GL.Enums.FfdTargetSGIX target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, [In, Out] Double[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = points)
|
|
{
|
|
Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3(GL.Enums.FfdTargetSGIX target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, ref Double points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* points_ptr = &points)
|
|
{
|
|
Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeformationMap3(GL.Enums.FfdTargetSGIX target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, Single* points)
|
|
{
|
|
unsafe { Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points); }
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3(GL.Enums.FfdTargetSGIX target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, [In, Out] Single[] points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = points)
|
|
{
|
|
Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeformationMap3(GL.Enums.FfdTargetSGIX target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, ref Single points)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* points_ptr = &points)
|
|
{
|
|
Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeformSGIX(GL.Enums.FfdMaskSGIX mask)
|
|
{
|
|
Delegates.glDeformSGIX((GL.Enums.FfdMaskSGIX)mask);
|
|
}
|
|
|
|
public static
|
|
void LoadIdentityDeformationMapSGIX(GL.Enums.FfdMaskSGIX mask)
|
|
{
|
|
Delegates.glLoadIdentityDeformationMapSGIX((GL.Enums.FfdMaskSGIX)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReferencePlaneSGIX(Double* equation)
|
|
{
|
|
unsafe { Delegates.glReferencePlaneSGIX((Double*)equation); }
|
|
}
|
|
|
|
public static
|
|
void ReferencePlaneSGIX([In, Out] Double[] equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = equation)
|
|
{
|
|
Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReferencePlaneSGIX(ref Double equation)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* equation_ptr = &equation)
|
|
{
|
|
Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FlushRasterSGIX()
|
|
{
|
|
Delegates.glFlushRasterSGIX();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetListParameterv(Int32 list, GL.Enums.ListParameterName pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterfSGIX(UInt32 list, GL.Enums.ListParameterName pname, Single param)
|
|
{
|
|
Delegates.glListParameterfSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single)param);
|
|
}
|
|
|
|
public static
|
|
void ListParameterfSGIX(Int32 list, GL.Enums.ListParameterName pname, Single param)
|
|
{
|
|
Delegates.glListParameterfSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterfvSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameteriSGIX(UInt32 list, GL.Enums.ListParameterName pname, Int32 param)
|
|
{
|
|
Delegates.glListParameteriSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void ListParameteriSGIX(Int32 list, GL.Enums.ListParameterName pname, Int32 param)
|
|
{
|
|
Delegates.glListParameteriSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ListParameterv(UInt32 list, GL.Enums.ListParameterName pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ListParameterv(Int32 list, GL.Enums.ListParameterName pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glListParameterivSGIX((UInt32)list, (GL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentColorMaterialSGIX(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
|
|
{
|
|
Delegates.glFragmentColorMaterialSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
|
|
}
|
|
|
|
public static
|
|
void FragmentLightfSGIX(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, Single param)
|
|
{
|
|
Delegates.glFragmentLightfSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightiSGIX(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, Int32 param)
|
|
{
|
|
Delegates.glFragmentLightiSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelfSGIX(GL.Enums.FragmentLightModelParameterSGIX pname, Single param)
|
|
{
|
|
Delegates.glFragmentLightModelfSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModeliSGIX(GL.Enums.FragmentLightModelParameterSGIX pname, Int32 param)
|
|
{
|
|
Delegates.glFragmentLightModeliSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentLightModelv(GL.Enums.FragmentLightModelParameterSGIX pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialfSGIX(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Single param)
|
|
{
|
|
Delegates.glFragmentMaterialfSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialiSGIX(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Int32 param)
|
|
{
|
|
Delegates.glFragmentMaterialiSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentLightv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFragmentMaterialv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LightEnviSGIX(GL.Enums.LightEnvParameterSGIX pname, Int32 param)
|
|
{
|
|
Delegates.glLightEnviSGIX((GL.Enums.LightEnvParameterSGIX)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AsyncMarkerSGIX(UInt32 marker)
|
|
{
|
|
Delegates.glAsyncMarkerSGIX((UInt32)marker);
|
|
}
|
|
|
|
public static
|
|
void AsyncMarkerSGIX(Int32 marker)
|
|
{
|
|
Delegates.glAsyncMarkerSGIX((UInt32)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 FinishAsyncSGIX([Out] UInt32* markerp)
|
|
{
|
|
unsafe { return Delegates.glFinishAsyncSGIX((UInt32*)markerp); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 FinishAsyncSGIX([Out] Int32* markerp)
|
|
{
|
|
markerp = default(Int32*);
|
|
{
|
|
Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 FinishAsyncSGIX([In, Out] UInt32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* markerp_ptr = markerp)
|
|
{
|
|
Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 FinishAsyncSGIX([In, Out] Int32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = markerp)
|
|
{
|
|
Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 FinishAsyncSGIX([Out] out UInt32 markerp)
|
|
{
|
|
markerp = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* markerp_ptr = &markerp)
|
|
{
|
|
Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 FinishAsyncSGIX([Out] out Int32 markerp)
|
|
{
|
|
markerp = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = &markerp)
|
|
{
|
|
Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 PollAsyncSGIX([Out] UInt32* markerp)
|
|
{
|
|
unsafe { return Delegates.glPollAsyncSGIX((UInt32*)markerp); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 PollAsyncSGIX([Out] Int32* markerp)
|
|
{
|
|
markerp = default(Int32*);
|
|
{
|
|
Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 PollAsyncSGIX([In, Out] UInt32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* markerp_ptr = markerp)
|
|
{
|
|
Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 PollAsyncSGIX([In, Out] Int32[] markerp)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = markerp)
|
|
{
|
|
Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 PollAsyncSGIX([Out] out UInt32 markerp)
|
|
{
|
|
markerp = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* markerp_ptr = &markerp)
|
|
{
|
|
Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 PollAsyncSGIX([Out] out Int32 markerp)
|
|
{
|
|
markerp = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* markerp_ptr = &markerp)
|
|
{
|
|
Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
|
|
markerp = *markerp_ptr;
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
Int32 GenAsyncMarkersSGIX(Int32 range)
|
|
{
|
|
return Delegates.glGenAsyncMarkersSGIX((Int32)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteAsyncMarkersSGIX(UInt32 marker, Int32 range)
|
|
{
|
|
Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
|
|
}
|
|
|
|
public static
|
|
void DeleteAsyncMarkersSGIX(Int32 marker, Int32 range)
|
|
{
|
|
Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsAsyncMarkerSGIX(UInt32 marker)
|
|
{
|
|
return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
|
|
}
|
|
|
|
public static
|
|
Boolean IsAsyncMarkerSGIX(Int32 marker)
|
|
{
|
|
return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IglooInterfaceSGIX(GL.Enums.All pname, void* @params)
|
|
{
|
|
unsafe { Delegates.glIglooInterfaceSGIX((GL.Enums.All)pname, (void*)@params); }
|
|
}
|
|
|
|
public static
|
|
void IglooInterfaceSGIX(GL.Enums.All pname, [In, Out] 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.All)pname, (void*)@params_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@params_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class HP
|
|
{
|
|
public static
|
|
void ImageTransformParameteriHP(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, Int32 param)
|
|
{
|
|
Delegates.glImageTransformParameteriHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterfHP(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, Single param)
|
|
{
|
|
Delegates.glImageTransformParameterfHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetImageTransformParameterv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class PGI
|
|
{
|
|
public static
|
|
void HintPGI(GL.Enums.PGI_misc_hints target, Int32 mode)
|
|
{
|
|
Delegates.glHintPGI((GL.Enums.PGI_misc_hints)target, (Int32)mode);
|
|
}
|
|
|
|
}
|
|
|
|
public static class SUNX
|
|
{
|
|
public static
|
|
void FinishTextureSUNX()
|
|
{
|
|
Delegates.glFinishTextureSUNX();
|
|
}
|
|
|
|
}
|
|
|
|
public static class SUN
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactorbSUN(SByte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorbSUN((SByte)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorbSUN(Byte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorbSUN((SByte)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorsSUN(Int16 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorsSUN((Int16)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactoriSUN(Int32 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoriSUN((Int32)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactorfSUN(Single factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorfSUN((Single)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactordSUN(Double factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactordSUN((Double)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactor(Byte factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorubSUN((Byte)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactor(UInt16 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactor(Int16 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GlobalAlphaFactor(UInt32 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
|
|
}
|
|
|
|
public static
|
|
void GlobalAlphaFactor(Int32 factor)
|
|
{
|
|
Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCode(UInt32 code)
|
|
{
|
|
Delegates.glReplacementCodeuiSUN((UInt32)code);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCode(Int32 code)
|
|
{
|
|
Delegates.glReplacementCodeuiSUN((UInt32)code);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCode(UInt16 code)
|
|
{
|
|
Delegates.glReplacementCodeusSUN((UInt16)code);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCode(Int16 code)
|
|
{
|
|
Delegates.glReplacementCodeusSUN((UInt16)code);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCode(Byte code)
|
|
{
|
|
Delegates.glReplacementCodeubSUN((Byte)code);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodev(UInt32* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuivSUN((UInt32*)code); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodev(Int32* code)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((UInt32*)code);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodev([In, Out] UInt32[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev([In, Out] Int32[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodev(ref UInt32 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev(ref Int32 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodev(UInt16* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeusvSUN((UInt16*)code); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodev(Int16* code)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((UInt16*)code);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodev([In, Out] UInt16[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev([In, Out] Int16[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodev(ref UInt16 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev(ref Int16 code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodev(Byte* code)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeubvSUN((Byte*)code); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev([In, Out] Byte[] code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* code_ptr = code)
|
|
{
|
|
Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodev(ref Byte code)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* code_ptr = &code)
|
|
{
|
|
Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodePointerSUN(GL.Enums.SUN_triangle_list type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glReplacementCodePointerSUN((GL.Enums.SUN_triangle_list)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodePointerSUN(GL.Enums.SUN_triangle_list type, Int32 stride, [In, Out] 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2(Byte r, Byte g, Byte b, Byte a, Single x, Single y)
|
|
{
|
|
Delegates.glColor4ubVertex2fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2v(Byte* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2v(Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2v(Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2v([In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2v([In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2v([In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex2v(ref Byte c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2v(ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex2v(ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3(Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glColor4ubVertex3fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3v(Byte* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3v(Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3v(Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3v([In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3v([In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3v([In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4ubVertex3v(ref Byte c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3v(ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4ubVertex3v(ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3(Single r, Single g, Single b, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glColor3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3v(Single* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3v(Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3v(Single* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3v([In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3v([In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3v([In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3fVertex3v(ref Single c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3v(ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3fVertex3v(ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3(Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glNormal3fVertex3fSUN((Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3v(Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3v(Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3v(Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3v([In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3v([In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3v([In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3fVertex3v(ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3v(ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3fVertex3v(ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3(Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v([In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v([In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v([In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v([In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v([In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v([In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v([In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v([In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v([In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v(ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v(ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4fNormal3fVertex3v(ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v(ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4fNormal3fVertex3v(ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3(Single s, Single t, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fSUN((Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3v(Single* tc, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3v(Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3v(Single* tc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3v([In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3v([In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3v([In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fVertex3v(ref Single tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3v(ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fVertex3v(ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4(Single s, Single t, Single p, Single q, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4v(Single* tc, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4v(Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4v(Single* tc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4v([In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4v([In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4v([In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fVertex4v(ref Single tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4v(ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fVertex4v(ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3(Single s, Single t, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fSUN((Single)s, (Single)t, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, Byte* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(Single* tc, ref Byte c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, Byte* c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v([In, Out] Single[] tc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(ref Single tc, Byte* c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(ref Single tc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(ref Single tc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(ref Single tc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v(ref Single tc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v(ref Single tc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4ubVertex3v(ref Single tc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v(ref Single tc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4ubVertex3v(ref Single tc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3(Single s, Single t, Single r, Single g, Single b, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, Single* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, Single* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, ref Single c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(Single* tc, ref Single c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, Single* c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, Single* c, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, ref Single c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v([In, Out] Single[] tc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(ref Single tc, Single* c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(ref Single tc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(ref Single tc, Single* c, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(ref Single tc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v(ref Single tc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor3fVertex3v(ref Single tc, ref Single c, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v(ref Single tc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor3fVertex3v(ref Single tc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3(Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v([In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v(ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v(ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fNormal3fVertex3v(ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v(ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fNormal3fVertex3v(ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3(Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v([In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2fColor4fNormal3fVertex3v(ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4(Single s, Single t, Single p, Single q, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v([In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4fColor4fNormal3fVertex4v(ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3(UInt32 rc, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3(Int32 rc, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(UInt32* rc, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(Int32* rc, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(UInt32* rc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(Int32* rc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(UInt32* rc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(Int32* rc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v([In, Out] UInt32[] rc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v([In, Out] Int32[] rc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3v([In, Out] Int32[] rc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3v([In, Out] UInt32[] rc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3v([In, Out] Int32[] rc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(ref UInt32 rc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiVertex3v(ref Int32 rc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3v(ref UInt32 rc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3v(ref Int32 rc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiVertex3v(ref UInt32 rc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiVertex3v(ref Int32 rc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3(UInt32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3(Int32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, Byte* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, Byte* c, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, ref Byte c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, ref Byte c, ref Single v)
|
|
{
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, Byte* c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, Byte* c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] UInt32[] rc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v([In, Out] Int32[] rc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, Byte* c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, Byte* c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, Byte* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, Byte* c, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, [In, Out] Byte[] c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, [In, Out] Byte[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, [In, Out] Byte[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, ref Byte c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, ref Byte c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, ref Byte c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Byte* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3(UInt32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3(Int32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, Single* c, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, Single* c, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, Single* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, Single* c, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, ref Single c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, ref Single c, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, ref Single c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, ref Single c, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, Single* c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, Single* c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, Single* c, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, Single* c, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, ref Single c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, ref Single c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] UInt32[] rc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v([In, Out] Int32[] rc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, Single* c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, Single* c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, Single* c, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, Single* c, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, Single* c, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, [In, Out] Single[] c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, [In, Out] Single[] c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, [In, Out] Single[] c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, ref Single c, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, ref Single c, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, ref Single c, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, ref Single c, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3(UInt32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3(Int32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, Single* n, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] UInt32[] rc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v([In, Out] Int32[] rc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3(UInt32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3(Int32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, Single* n, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3(UInt32 rc, Single s, Single t, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3(Int32 rc, Single s, Single t, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, Single* tc, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, Single* tc, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, ref Single tc, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, ref Single tc, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, Single* tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, Single* tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, Single* tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, Single* tc, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, ref Single tc, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, ref Single tc, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3(UInt32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3(Int32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3(UInt32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3(Int32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
unsafe { Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] UInt32[] rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v([In, Out] Int32[] rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, Single* tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, [In, Out] Single[] tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, Single* c, ref Single n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, [In, Out] Single[] c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, Single* n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, Single* n, [In, Out] Single[] v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, Single* n, ref Single v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, [In, Out] Single[] n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, ref Single n, Single* v)
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, ref Single n, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* rc_ptr = &rc)
|
|
fixed (Single* tc_ptr = &tc)
|
|
fixed (Single* c_ptr = &c)
|
|
fixed (Single* n_ptr = &n)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawMeshArraysSUN(GL.Enums.BeginMode mode, Int32 first, Int32 count, Int32 width)
|
|
{
|
|
Delegates.glDrawMeshArraysSUN((GL.Enums.BeginMode)mode, (Int32)first, (Int32)count, (Int32)width);
|
|
}
|
|
|
|
}
|
|
|
|
public static class INGR
|
|
{
|
|
public static
|
|
void BlendFuncSeparateINGR(GL.Enums.All sfactorRGB, GL.Enums.All dfactorRGB, GL.Enums.All sfactorAlpha, GL.Enums.All dfactorAlpha)
|
|
{
|
|
Delegates.glBlendFuncSeparateINGR((GL.Enums.All)sfactorRGB, (GL.Enums.All)dfactorRGB, (GL.Enums.All)sfactorAlpha, (GL.Enums.All)dfactorAlpha);
|
|
}
|
|
|
|
}
|
|
|
|
public static class NV
|
|
{
|
|
public static
|
|
void FlushVertexArrayRangeNV()
|
|
{
|
|
Delegates.glFlushVertexArrayRangeNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexArrayRangeNV(Int32 length, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexArrayRangeNV((Int32)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexArrayRangeNV(Int32 length, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexArrayRangeNV((Int32)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CombinerParameterv(GL.Enums.NV_register_combiners pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterv(GL.Enums.NV_register_combiners pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterv(GL.Enums.NV_register_combiners pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterfNV(GL.Enums.NV_register_combiners pname, Single param)
|
|
{
|
|
Delegates.glCombinerParameterfNV((GL.Enums.NV_register_combiners)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void CombinerParameterv(GL.Enums.NV_register_combiners pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterv(GL.Enums.NV_register_combiners pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameterv(GL.Enums.NV_register_combiners pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerParameteriNV(GL.Enums.NV_register_combiners pname, Int32 param)
|
|
{
|
|
Delegates.glCombinerParameteriNV((GL.Enums.NV_register_combiners)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void CombinerInputNV(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 CombinerOutputNV(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 FinalCombinerInputNV(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 GetCombinerInputParameterv(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] Single* @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, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @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, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterv(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] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @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, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerInputParameterv(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] Int32* @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, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @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, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerInputParameterv(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] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @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, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerOutputParameterv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFinalCombinerInputParameterv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFencesNV(Int32 n, UInt32* fences)
|
|
{
|
|
unsafe { Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFencesNV(Int32 n, Int32* fences)
|
|
{
|
|
{
|
|
Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFencesNV(Int32 n, [In, Out] UInt32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFencesNV(Int32 n, [In, Out] Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFencesNV(Int32 n, ref UInt32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFencesNV(Int32 n, ref Int32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFencesNV(Int32 n, [Out] UInt32* fences)
|
|
{
|
|
unsafe { Delegates.glGenFencesNV((Int32)n, (UInt32*)fences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFencesNV(Int32 n, [Out] Int32* fences)
|
|
{
|
|
fences = default(Int32*);
|
|
{
|
|
Delegates.glGenFencesNV((Int32)n, (UInt32*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFencesNV(Int32 n, [In, Out] UInt32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFencesNV(Int32 n, [In, Out] Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFencesNV(Int32 n, [Out] out UInt32 fences)
|
|
{
|
|
fences = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFencesNV(Int32 n, [Out] out Int32 fences)
|
|
{
|
|
fences = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsFenceNV(UInt32 fence)
|
|
{
|
|
return Delegates.glIsFenceNV((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
Boolean IsFenceNV(Int32 fence)
|
|
{
|
|
return Delegates.glIsFenceNV((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean TestFenceNV(UInt32 fence)
|
|
{
|
|
return Delegates.glTestFenceNV((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
Boolean TestFenceNV(Int32 fence)
|
|
{
|
|
return Delegates.glTestFenceNV((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFencev(UInt32 fence, GL.Enums.NV_fence pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetFencev(Int32 fence, GL.Enums.NV_fence pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetFencev(UInt32 fence, GL.Enums.NV_fence pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFencev(Int32 fence, GL.Enums.NV_fence pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetFencev(UInt32 fence, GL.Enums.NV_fence pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetFencev(Int32 fence, GL.Enums.NV_fence pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetFenceivNV((UInt32)fence, (GL.Enums.NV_fence)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FinishFenceNV(UInt32 fence)
|
|
{
|
|
Delegates.glFinishFenceNV((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
void FinishFenceNV(Int32 fence)
|
|
{
|
|
Delegates.glFinishFenceNV((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFenceNV(UInt32 fence, GL.Enums.NV_fence condition)
|
|
{
|
|
Delegates.glSetFenceNV((UInt32)fence, (GL.Enums.NV_fence)condition);
|
|
}
|
|
|
|
public static
|
|
void SetFenceNV(Int32 fence, GL.Enums.NV_fence condition)
|
|
{
|
|
Delegates.glSetFenceNV((UInt32)fence, (GL.Enums.NV_fence)condition);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapControlPointsNV(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
unsafe { Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (GL.Enums.Boolean)packed, (void*)points); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapControlPointsNV(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, GL.Enums.Boolean packed, void* points)
|
|
{
|
|
{
|
|
Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (GL.Enums.Boolean)packed, (void*)points);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapControlPointsNV(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators type, Int32 ustride, Int32 vstride, GL.Enums.Boolean packed, [Out] void* points)
|
|
{
|
|
unsafe { Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)type, (Int32)ustride, (Int32)vstride, (GL.Enums.Boolean)packed, (void*)points); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapControlPointsNV(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, Int32 ustride, Int32 vstride, GL.Enums.Boolean packed, [Out] void* points)
|
|
{
|
|
points = default(void*);
|
|
{
|
|
Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)type, (Int32)ustride, (Int32)vstride, (GL.Enums.Boolean)packed, (void*)points);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapParameterv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, UInt32 index, GL.Enums.NV_evaluators pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetMapAttribParameterv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (UInt32)index, (GL.Enums.NV_evaluators)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void EvalMapsNV(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 CombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, Single* @params)
|
|
{
|
|
unsafe { Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void CombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void CombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetCombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetCombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetCombinerStageParameterv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, UInt32* programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
unsafe { return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (GL.Enums.Boolean*)residences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, Int32* programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
{
|
|
Boolean retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, [In, Out] UInt32[] programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Boolean retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, [In, Out] Int32[] programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Boolean retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, ref UInt32 programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Boolean retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Boolean AreProgramsResidentNV(Int32 n, ref Int32 programs, [Out] GL.Enums.Boolean* residences)
|
|
{
|
|
residences = default(GL.Enums.Boolean*);
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Boolean retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (GL.Enums.Boolean*)residences);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindProgramNV(GL.Enums.NV_vertex_program target, UInt32 id)
|
|
{
|
|
Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BindProgramNV(GL.Enums.NV_vertex_program target, Int32 id)
|
|
{
|
|
Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteProgramsNV(Int32 n, UInt32* programs)
|
|
{
|
|
unsafe { Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteProgramsNV(Int32 n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgramsNV(Int32 n, [In, Out] UInt32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteProgramsNV(Int32 n, [In, Out] Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteProgramsNV(Int32 n, ref UInt32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteProgramsNV(Int32 n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ExecuteProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, Single* @params)
|
|
{
|
|
unsafe { Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ExecuteProgramNV(GL.Enums.NV_vertex_program target, Int32 id, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExecuteProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ExecuteProgramNV(GL.Enums.NV_vertex_program target, Int32 id, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ExecuteProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ExecuteProgramNV(GL.Enums.NV_vertex_program target, Int32 id, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenProgramsNV(Int32 n, [Out] UInt32* programs)
|
|
{
|
|
unsafe { Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenProgramsNV(Int32 n, [Out] Int32* programs)
|
|
{
|
|
programs = default(Int32*);
|
|
{
|
|
Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenProgramsNV(Int32 n, [In, Out] UInt32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenProgramsNV(Int32 n, [In, Out] Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenProgramsNV(Int32 n, [Out] out UInt32 programs)
|
|
{
|
|
programs = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenProgramsNV(Int32 n, [Out] out Int32 programs)
|
|
{
|
|
programs = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
programs = *programs_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, UInt32 index, GL.Enums.NV_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramParameterv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramv(UInt32 id, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramv(Int32 id, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramv(UInt32 id, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(Int32 id, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramv(UInt32 id, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramv(Int32 id, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramivNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramStringNV(UInt32 id, GL.Enums.NV_vertex_program pname, [Out] Byte* program)
|
|
{
|
|
unsafe { Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramStringNV(Int32 id, GL.Enums.NV_vertex_program pname, [Out] Byte* program)
|
|
{
|
|
program = default(Byte*);
|
|
{
|
|
Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramStringNV(UInt32 id, GL.Enums.NV_vertex_program pname, [In, Out] Byte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = program)
|
|
{
|
|
Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramStringNV(Int32 id, GL.Enums.NV_vertex_program pname, [In, Out] Byte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = program)
|
|
{
|
|
Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramStringNV(UInt32 id, GL.Enums.NV_vertex_program pname, [Out] out Byte program)
|
|
{
|
|
program = default(Byte);
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = &program)
|
|
{
|
|
Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program_ptr);
|
|
program = *program_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramStringNV(Int32 id, GL.Enums.NV_vertex_program pname, [Out] out Byte program)
|
|
{
|
|
program = default(Byte);
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = &program)
|
|
{
|
|
Delegates.glGetProgramStringNV((UInt32)id, (GL.Enums.NV_vertex_program)pname, (Byte*)program_ptr);
|
|
program = *program_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTrackMatrixv(GL.Enums.NV_vertex_program target, UInt32 address, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTrackMatrixv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTrackMatrixv(GL.Enums.NV_vertex_program target, UInt32 address, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTrackMatrixv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTrackMatrixv(GL.Enums.NV_vertex_program target, UInt32 address, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTrackMatrixv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribdvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribfvNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribv(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribv(Int32 index, GL.Enums.NV_vertex_program pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribivNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointervNV(UInt32 index, GL.Enums.NV_vertex_program pname, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribPointervNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribPointervNV(Int32 index, GL.Enums.NV_vertex_program pname, [Out] void* pointer)
|
|
{
|
|
pointer = default(void*);
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribPointervNV(UInt32 index, GL.Enums.NV_vertex_program pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribPointervNV(Int32 index, GL.Enums.NV_vertex_program pname, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glGetVertexAttribPointervNV((UInt32)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsProgramNV(UInt32 id)
|
|
{
|
|
return Delegates.glIsProgramNV((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
Boolean IsProgramNV(Int32 id)
|
|
{
|
|
return Delegates.glIsProgramNV((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, Int32 len, Byte* program)
|
|
{
|
|
unsafe { Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void LoadProgramNV(GL.Enums.NV_vertex_program target, Int32 id, Int32 len, Byte* program)
|
|
{
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, Int32 len, [In, Out] Byte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadProgramNV(GL.Enums.NV_vertex_program target, Int32 id, Int32 len, [In, Out] Byte[] program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void LoadProgramNV(GL.Enums.NV_vertex_program target, UInt32 id, Int32 len, ref Byte program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = &program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void LoadProgramNV(GL.Enums.NV_vertex_program target, Int32 id, Int32 len, ref Byte program)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* program_ptr = &program)
|
|
{
|
|
Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4(GL.Enums.NV_vertex_program target, UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4(GL.Enums.NV_vertex_program target, Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4(GL.Enums.NV_vertex_program target, UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4(GL.Enums.NV_vertex_program target, Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameter4v(GL.Enums.NV_vertex_program target, Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, Double* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, Double* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, Single* v)
|
|
{
|
|
unsafe { Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, Single* v)
|
|
{
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, UInt32 index, UInt32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramParameters4v(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RequestResidentProgramsNV(Int32 n, UInt32* programs)
|
|
{
|
|
unsafe { Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void RequestResidentProgramsNV(Int32 n, Int32* programs)
|
|
{
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void RequestResidentProgramsNV(Int32 n, [In, Out] UInt32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RequestResidentProgramsNV(Int32 n, [In, Out] Int32[] programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void RequestResidentProgramsNV(Int32 n, ref UInt32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void RequestResidentProgramsNV(Int32 n, ref Int32 programs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* programs_ptr = &programs)
|
|
{
|
|
Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TrackMatrixNV(GL.Enums.NV_vertex_program target, UInt32 address, GL.Enums.NV_vertex_program matrix, GL.Enums.NV_vertex_program transform)
|
|
{
|
|
Delegates.glTrackMatrixNV((GL.Enums.NV_vertex_program)target, (UInt32)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
|
|
}
|
|
|
|
public static
|
|
void TrackMatrixNV(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, (UInt32)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointerNV(UInt32 index, Int32 fsize, GL.Enums.NV_vertex_program type, Int32 stride, void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (GL.Enums.NV_vertex_program)type, (Int32)stride, (void*)pointer); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribPointerNV(Int32 index, Int32 fsize, GL.Enums.NV_vertex_program type, Int32 stride, void* pointer)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (GL.Enums.NV_vertex_program)type, (Int32)stride, (void*)pointer);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribPointerNV(UInt32 index, Int32 fsize, GL.Enums.NV_vertex_program type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (GL.Enums.NV_vertex_program)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribPointerNV(Int32 index, Int32 fsize, GL.Enums.NV_vertex_program type, Int32 stride, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (GL.Enums.NV_vertex_program)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Double x)
|
|
{
|
|
Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Single x)
|
|
{
|
|
Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1(UInt32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1(Int32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Double x, Double y)
|
|
{
|
|
Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Single x, Single y)
|
|
{
|
|
Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2(Int32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4(UInt32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4(Int32 index, Byte x, Byte y, Byte z, Byte w)
|
|
{
|
|
Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(UInt32 index, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4v(Int32 index, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4v(UInt32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4v(Int32 index, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(UInt32 index, Int32 count, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(Int32 index, Int32 count, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(UInt32 index, Int32 count, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(Int32 index, Int32 count, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(UInt32 index, Int32 count, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1v(Int32 index, Int32 count, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1v(UInt32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1v(Int32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(UInt32 index, Int32 count, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(Int32 index, Int32 count, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(UInt32 index, Int32 count, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(Int32 index, Int32 count, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(UInt32 index, Int32 count, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2v(Int32 index, Int32 count, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2v(UInt32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2v(Int32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(UInt32 index, Int32 count, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(Int32 index, Int32 count, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(UInt32 index, Int32 count, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(Int32 index, Int32 count, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(UInt32 index, Int32 count, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3v(Int32 index, Int32 count, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3v(UInt32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3v(Int32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(UInt32 index, Int32 count, Double* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(Int32 index, Int32 count, Double* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(UInt32 index, Int32 count, Single* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(Int32 index, Int32 count, Single* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(UInt32 index, Int32 count, Int16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(Int32 index, Int32 count, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(UInt32 index, Int32 count, Byte* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4v(Int32 index, Int32 count, Byte* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, [In, Out] Byte[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4v(UInt32 index, Int32 count, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4v(Int32 index, Int32 count, ref Byte v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenOcclusionQueriesNV(Int32 n, [Out] UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenOcclusionQueriesNV(Int32 n, [Out] Int32* ids)
|
|
{
|
|
ids = default(Int32*);
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenOcclusionQueriesNV(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenOcclusionQueriesNV(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenOcclusionQueriesNV(Int32 n, [Out] out UInt32 ids)
|
|
{
|
|
ids = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenOcclusionQueriesNV(Int32 n, [Out] out Int32 ids)
|
|
{
|
|
ids = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
ids = *ids_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteOcclusionQueriesNV(Int32 n, UInt32* ids)
|
|
{
|
|
unsafe { Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteOcclusionQueriesNV(Int32 n, Int32* ids)
|
|
{
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteOcclusionQueriesNV(Int32 n, [In, Out] UInt32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteOcclusionQueriesNV(Int32 n, [In, Out] Int32[] ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteOcclusionQueriesNV(Int32 n, ref UInt32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteOcclusionQueriesNV(Int32 n, ref Int32 ids)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* ids_ptr = &ids)
|
|
{
|
|
Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsOcclusionQueryNV(UInt32 id)
|
|
{
|
|
return Delegates.glIsOcclusionQueryNV((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
Boolean IsOcclusionQueryNV(Int32 id)
|
|
{
|
|
return Delegates.glIsOcclusionQueryNV((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BeginOcclusionQueryNV(UInt32 id)
|
|
{
|
|
Delegates.glBeginOcclusionQueryNV((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BeginOcclusionQueryNV(Int32 id)
|
|
{
|
|
Delegates.glBeginOcclusionQueryNV((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void EndOcclusionQueryNV()
|
|
{
|
|
Delegates.glEndOcclusionQueryNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryv(Int32 id, GL.Enums.NV_occlusion_query pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryv(Int32 id, GL.Enums.NV_occlusion_query pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetOcclusionQueryv(Int32 id, GL.Enums.NV_occlusion_query pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetOcclusionQueryuivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetOcclusionQueryv(UInt32 id, GL.Enums.NV_occlusion_query pname, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetOcclusionQueryuivNV((UInt32)id, (GL.Enums.NV_occlusion_query)pname, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameteriNV(GL.Enums.NV_point_sprite pname, Int32 param)
|
|
{
|
|
Delegates.glPointParameteriNV((GL.Enums.NV_point_sprite)pname, (Int32)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PointParameterv(GL.Enums.NV_point_sprite pname, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.NV_point_sprite pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PointParameterv(GL.Enums.NV_point_sprite pname, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Single x, Single y, Single z, Single w)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Single x, Single y, Single z, Single w)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4(UInt32 id, Int32 len, [In, Out] Byte[] name, Single x, Single y, Single z, Single w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4(Int32 id, Int32 len, [In, Out] Byte[] name, Single x, Single y, Single z, Single w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Double x, Double y, Double z, Double w)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Double x, Double y, Double z, Double w)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4(UInt32 id, Int32 len, [In, Out] Byte[] name, Double x, Double y, Double z, Double w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4(Int32 id, Int32 len, [In, Out] Byte[] name, Double x, Double y, Double z, Double w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, Single* v)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, Single* v)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, [In, Out] Single[] v)
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, ref Single v)
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, Single* v)
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, Single* v)
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, Single* v)
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, Single* v)
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, [In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, Double* v)
|
|
{
|
|
unsafe { Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, Double* v)
|
|
{
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, [In, Out] Double[] v)
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, [In, Out] Double[] v)
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, Byte* name, ref Double v)
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, Byte* name, ref Double v)
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, Double* v)
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, Double* v)
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, [In, Out] Byte[] name, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, [In, Out] Byte[] name, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, Double* v)
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, Double* v)
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, [In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramNamedParameter4v(UInt32 id, Int32 len, ref Byte name, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramNamedParameter4v(Int32 id, Int32 len, ref Byte name, ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [In, Out] Single[] @params)
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [In, Out] Single[] @params)
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [Out] Double* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [In, Out] Double[] @params)
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [In, Out] Double[] @params)
|
|
{
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, Byte* name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, Byte* name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
fixed (Byte* name_ptr = name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, [In, Out] Byte[] name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, [In, Out] Byte[] name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = name)
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [Out] Double* @params)
|
|
{
|
|
@params = default(Double*);
|
|
fixed (Byte* name_ptr = &name)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [In, Out] Double[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramNamedParameterv(UInt32 id, Int32 len, ref Byte name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramNamedParameterv(Int32 id, Int32 len, ref Byte name, [Out] out Double @params)
|
|
{
|
|
@params = default(Double);
|
|
unsafe
|
|
{
|
|
fixed (Byte* name_ptr = &name)
|
|
fixed (Double* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2hNV(UInt16 x, UInt16 y)
|
|
{
|
|
Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
|
|
}
|
|
|
|
public static
|
|
void Vertex2hNV(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertex2hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex2hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex2hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex2hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex2hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3hNV(UInt16 x, UInt16 y, UInt16 z)
|
|
{
|
|
Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
|
|
}
|
|
|
|
public static
|
|
void Vertex3hNV(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertex3hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex3hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex3hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex3hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex3hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4hNV(UInt16 x, UInt16 y, UInt16 z, UInt16 w)
|
|
{
|
|
Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
|
|
}
|
|
|
|
public static
|
|
void Vertex4hNV(Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertex4hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Vertex4hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertex4hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertex4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Vertex4hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Vertex4hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertex4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3hNV(UInt16 nx, UInt16 ny, UInt16 nz)
|
|
{
|
|
Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
|
|
}
|
|
|
|
public static
|
|
void Normal3hNV(Int16 nx, Int16 ny, Int16 nz)
|
|
{
|
|
Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glNormal3hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Normal3hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glNormal3hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glNormal3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Normal3hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Normal3hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glNormal3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3hNV(UInt16 red, UInt16 green, UInt16 blue)
|
|
{
|
|
Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
public static
|
|
void Color3hNV(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glColor3hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color3hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor3hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color3hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color3hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4hNV(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
|
|
{
|
|
Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
|
|
}
|
|
|
|
public static
|
|
void Color4hNV(Int16 red, Int16 green, Int16 blue, Int16 alpha)
|
|
{
|
|
Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glColor4hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void Color4hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glColor4hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glColor4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void Color4hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void Color4hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glColor4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1hNV(UInt16 s)
|
|
{
|
|
Delegates.glTexCoord1hNV((UInt16)s);
|
|
}
|
|
|
|
public static
|
|
void TexCoord1hNV(Int16 s)
|
|
{
|
|
Delegates.glTexCoord1hNV((UInt16)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord1hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord1hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord1hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord1hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord1hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2hNV(UInt16 s, UInt16 t)
|
|
{
|
|
Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
|
|
}
|
|
|
|
public static
|
|
void TexCoord2hNV(Int16 s, Int16 t)
|
|
{
|
|
Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord2hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord2hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord2hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord2hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord2hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3hNV(UInt16 s, UInt16 t, UInt16 r)
|
|
{
|
|
Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
|
|
}
|
|
|
|
public static
|
|
void TexCoord3hNV(Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord3hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord3hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord3hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord3hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord3hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4hNV(UInt16 s, UInt16 t, UInt16 r, UInt16 q)
|
|
{
|
|
Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
|
|
}
|
|
|
|
public static
|
|
void TexCoord4hNV(Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glTexCoord4hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoord4hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glTexCoord4hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TexCoord4hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexCoord4hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1hNV(GL.Enums.NV_half_float target, UInt16 s)
|
|
{
|
|
Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (UInt16)s);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1hNV(GL.Enums.NV_half_float target, Int16 s)
|
|
{
|
|
Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (UInt16)s);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord1hvNV(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2hNV(GL.Enums.NV_half_float target, UInt16 s, UInt16 t)
|
|
{
|
|
Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2hNV(GL.Enums.NV_half_float target, Int16 s, Int16 t)
|
|
{
|
|
Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord2hvNV(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3hNV(GL.Enums.NV_half_float target, UInt16 s, UInt16 t, UInt16 r)
|
|
{
|
|
Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t, (UInt16)r);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3hNV(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r)
|
|
{
|
|
Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t, (UInt16)r);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord3hvNV(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4hNV(GL.Enums.NV_half_float target, UInt16 s, UInt16 t, UInt16 r, UInt16 q)
|
|
{
|
|
Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4hNV(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r, Int16 q)
|
|
{
|
|
Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiTexCoord4hvNV(GL.Enums.NV_half_float target, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordhNV(UInt16 fog)
|
|
{
|
|
Delegates.glFogCoordhNV((UInt16)fog);
|
|
}
|
|
|
|
public static
|
|
void FogCoordhNV(Int16 fog)
|
|
{
|
|
Delegates.glFogCoordhNV((UInt16)fog);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordhvNV(UInt16* fog)
|
|
{
|
|
unsafe { Delegates.glFogCoordhvNV((UInt16*)fog); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordhvNV(Int16* fog)
|
|
{
|
|
{
|
|
Delegates.glFogCoordhvNV((UInt16*)fog);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordhvNV([In, Out] UInt16[] fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* fog_ptr = fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordhvNV([In, Out] Int16[] fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* fog_ptr = fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FogCoordhvNV(ref UInt16 fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* fog_ptr = &fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FogCoordhvNV(ref Int16 fog)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* fog_ptr = &fog)
|
|
{
|
|
Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3hNV(UInt16 red, UInt16 green, UInt16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3hNV(Int16 red, Int16 green, Int16 blue)
|
|
{
|
|
Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3hvNV(UInt16* v)
|
|
{
|
|
unsafe { Delegates.glSecondaryColor3hvNV((UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColor3hvNV(Int16* v)
|
|
{
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3hvNV([In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3hvNV([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SecondaryColor3hvNV(ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SecondaryColor3hvNV(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighthNV(UInt16 weight)
|
|
{
|
|
Delegates.glVertexWeighthNV((UInt16)weight);
|
|
}
|
|
|
|
public static
|
|
void VertexWeighthNV(Int16 weight)
|
|
{
|
|
Delegates.glVertexWeighthNV((UInt16)weight);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeighthvNV(UInt16* weight)
|
|
{
|
|
unsafe { Delegates.glVertexWeighthvNV((UInt16*)weight); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexWeighthvNV(Int16* weight)
|
|
{
|
|
{
|
|
Delegates.glVertexWeighthvNV((UInt16*)weight);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighthvNV([In, Out] UInt16[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeighthvNV([In, Out] Int16[] weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weight_ptr = weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexWeighthvNV(ref UInt16 weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexWeighthvNV(ref Int16 weight)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* weight_ptr = &weight)
|
|
{
|
|
Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1hNV(UInt32 index, UInt16 x)
|
|
{
|
|
Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1hNV(Int32 index, Int16 x)
|
|
{
|
|
Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1hvNV(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib1hvNV(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1hvNV(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1hvNV(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib1hvNV(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib1hvNV(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2hNV(UInt32 index, UInt16 x, UInt16 y)
|
|
{
|
|
Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2hNV(Int32 index, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2hvNV(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib2hvNV(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2hvNV(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2hvNV(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib2hvNV(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib2hvNV(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3hNV(UInt32 index, UInt16 x, UInt16 y, UInt16 z)
|
|
{
|
|
Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3hNV(Int32 index, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3hvNV(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib3hvNV(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3hvNV(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3hvNV(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib3hvNV(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib3hvNV(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4hNV(UInt32 index, UInt16 x, UInt16 y, UInt16 z, UInt16 w)
|
|
{
|
|
Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4hNV(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4hvNV(UInt32 index, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttrib4hvNV(Int32 index, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4hvNV(UInt32 index, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4hvNV(Int32 index, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttrib4hvNV(UInt32 index, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttrib4hvNV(Int32 index, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1hvNV(UInt32 index, Int32 n, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs1hvNV(Int32 index, Int32 n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1hvNV(UInt32 index, Int32 n, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1hvNV(Int32 index, Int32 n, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs1hvNV(UInt32 index, Int32 n, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs1hvNV(Int32 index, Int32 n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2hvNV(UInt32 index, Int32 n, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs2hvNV(Int32 index, Int32 n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2hvNV(UInt32 index, Int32 n, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2hvNV(Int32 index, Int32 n, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs2hvNV(UInt32 index, Int32 n, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs2hvNV(Int32 index, Int32 n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3hvNV(UInt32 index, Int32 n, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs3hvNV(Int32 index, Int32 n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3hvNV(UInt32 index, Int32 n, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3hvNV(Int32 index, Int32 n, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs3hvNV(UInt32 index, Int32 n, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs3hvNV(Int32 index, Int32 n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4hvNV(UInt32 index, Int32 n, UInt16* v)
|
|
{
|
|
unsafe { Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexAttribs4hvNV(Int32 index, Int32 n, Int16* v)
|
|
{
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4hvNV(UInt32 index, Int32 n, [In, Out] UInt16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4hvNV(Int32 index, Int32 n, [In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribs4hvNV(UInt32 index, Int32 n, ref UInt16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexAttribs4hvNV(Int32 index, Int32 n, ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void PixelDataRangeNV(GL.Enums.NV_pixel_data_range target, Int32 length, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target, (Int32)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void PixelDataRangeNV(GL.Enums.NV_pixel_data_range target, Int32 length, [In, Out] 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, (Int32)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void FlushPixelDataRangeNV(GL.Enums.NV_pixel_data_range target)
|
|
{
|
|
Delegates.glFlushPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target);
|
|
}
|
|
|
|
public static
|
|
void PrimitiveRestartNV()
|
|
{
|
|
Delegates.glPrimitiveRestartNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PrimitiveRestartIndexNV(UInt32 index)
|
|
{
|
|
Delegates.glPrimitiveRestartIndexNV((UInt32)index);
|
|
}
|
|
|
|
public static
|
|
void PrimitiveRestartIndexNV(Int32 index)
|
|
{
|
|
Delegates.glPrimitiveRestartIndexNV((UInt32)index);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4(GL.Enums.NV_gpu_program4 target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramLocalParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4(GL.Enums.NV_gpu_program4 target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParameterI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramEnvParametersI4v(GL.Enums.NV_gpu_program4 target, UInt32 index, Int32 count, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramLocalParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, Int32 index, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetProgramEnvParameterIv(GL.Enums.NV_gpu_program4 target, UInt32 index, [Out] out UInt32 @params)
|
|
{
|
|
@params = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (UInt32)index, (UInt32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramVertexLimitNV(GL.Enums.NV_geometry_program4 target, Int32 limit)
|
|
{
|
|
Delegates.glProgramVertexLimitNV((GL.Enums.NV_geometry_program4)target, (Int32)limit);
|
|
}
|
|
|
|
public static
|
|
void DepthRangedNV(Double zNear, Double zFar)
|
|
{
|
|
Delegates.glDepthRangedNV((Double)zNear, (Double)zFar);
|
|
}
|
|
|
|
public static
|
|
void ClearDepthdNV(Double depth)
|
|
{
|
|
Delegates.glClearDepthdNV((Double)depth);
|
|
}
|
|
|
|
public static
|
|
void DepthBoundsdNV(Double zmin, Double zmax)
|
|
{
|
|
Delegates.glDepthBoundsdNV((Double)zmin, (Double)zmax);
|
|
}
|
|
|
|
public static
|
|
void RenderbufferStorageMultisampleCoverageNV(GL.Enums.NV_framebuffer_multisample_coverage target, Int32 coverageSamples, Int32 colorSamples, GL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height)
|
|
{
|
|
Delegates.glRenderbufferStorageMultisampleCoverageNV((GL.Enums.NV_framebuffer_multisample_coverage)target, (Int32)coverageSamples, (Int32)colorSamples, (GL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, Single* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, Single* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, ref Single @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, Int32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, Int32* @params)
|
|
{
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, Int32 count, ref Int32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, UInt32* @params)
|
|
{
|
|
unsafe { Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, [In, Out] UInt32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = @params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ProgramBufferParametersIv(GL.Enums.NV_parameter_buffer_object target, UInt32 buffer, UInt32 index, Int32 count, ref UInt32 @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void BeginTransformFeedbackNV(GL.Enums.NV_transform_feedback primitiveMode)
|
|
{
|
|
Delegates.glBeginTransformFeedbackNV((GL.Enums.NV_transform_feedback)primitiveMode);
|
|
}
|
|
|
|
public static
|
|
void EndTransformFeedbackNV()
|
|
{
|
|
Delegates.glEndTransformFeedbackNV();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackAttribsNV(UInt32 count, Int32* attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe { Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (GL.Enums.NV_transform_feedback)bufferMode); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackAttribsNV(Int32 count, Int32* attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackAttribsNV(UInt32 count, [In, Out] Int32[] attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* attribs_ptr = attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackAttribsNV(Int32 count, [In, Out] Int32[] attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* attribs_ptr = attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackAttribsNV(UInt32 count, ref Int32 attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* attribs_ptr = &attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackAttribsNV(Int32 count, ref Int32 attribs, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* attribs_ptr = &attribs)
|
|
{
|
|
Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferRangeNV(GL.Enums.NV_transform_feedback target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
|
|
{
|
|
Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
|
|
}
|
|
|
|
public static
|
|
void BindBufferRangeNV(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, IntPtr offset, IntPtr size)
|
|
{
|
|
Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferOffsetNV(GL.Enums.NV_transform_feedback target, UInt32 index, UInt32 buffer, IntPtr offset)
|
|
{
|
|
Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
|
|
}
|
|
|
|
public static
|
|
void BindBufferOffsetNV(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, IntPtr offset)
|
|
{
|
|
Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindBufferBaseNV(GL.Enums.NV_transform_feedback target, UInt32 index, UInt32 buffer)
|
|
{
|
|
Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void BindBufferBaseNV(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer)
|
|
{
|
|
Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (UInt32)index, (UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackVaryingsNV(UInt32 program, Int32 count, Int32* locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe { Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (GL.Enums.NV_transform_feedback)bufferMode); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TransformFeedbackVaryingsNV(Int32 program, Int32 count, Int32* locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackVaryingsNV(UInt32 program, Int32 count, [In, Out] Int32[] locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* locations_ptr = locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackVaryingsNV(Int32 program, Int32 count, [In, Out] Int32[] locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* locations_ptr = locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void TransformFeedbackVaryingsNV(UInt32 program, Int32 count, ref Int32 locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* locations_ptr = &locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TransformFeedbackVaryingsNV(Int32 program, Int32 count, ref Int32 locations, GL.Enums.NV_transform_feedback bufferMode)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* locations_ptr = &locations)
|
|
{
|
|
Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ActiveVaryingNV(UInt32 program, System.String name)
|
|
{
|
|
Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
void ActiveVaryingNV(Int32 program, System.String name)
|
|
{
|
|
Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GetVaryingLocationNV(UInt32 program, System.String name)
|
|
{
|
|
return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
public static
|
|
Int32 GetVaryingLocationNV(Int32 program, System.String name)
|
|
{
|
|
return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
unsafe { Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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 GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32*);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)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 GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [In, Out] Int32[] length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32* size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32*);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [In, Out] Int32[] size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] GL.Enums.NV_transform_feedback* type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback*);
|
|
name = default(System.Text.StringBuilder);
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [In, Out] GL.Enums.NV_transform_feedback[] type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
|
|
length = *length_ptr;
|
|
size = *size_ptr;
|
|
type = *type_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out GL.Enums.NV_transform_feedback type, [Out] System.Text.StringBuilder name)
|
|
{
|
|
length = default(Int32);
|
|
size = default(Int32);
|
|
type = default(GL.Enums.NV_transform_feedback);
|
|
name = default(System.Text.StringBuilder);
|
|
unsafe
|
|
{
|
|
fixed (Int32* length_ptr = &length)
|
|
fixed (Int32* size_ptr = &size)
|
|
fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
|
|
{
|
|
Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)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 GetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [Out] Int32* location)
|
|
{
|
|
unsafe { Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTransformFeedbackVaryingNV(Int32 program, Int32 index, [Out] Int32* location)
|
|
{
|
|
location = default(Int32*);
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [In, Out] Int32[] location)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* location_ptr = location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTransformFeedbackVaryingNV(Int32 program, Int32 index, [In, Out] Int32[] location)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* location_ptr = location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [Out] out Int32 location)
|
|
{
|
|
location = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* location_ptr = &location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
|
|
location = *location_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTransformFeedbackVaryingNV(Int32 program, Int32 index, [Out] out Int32 location)
|
|
{
|
|
location = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* location_ptr = &location)
|
|
{
|
|
Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
|
|
location = *location_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class MESA
|
|
{
|
|
public static
|
|
void ResizeBuffersMESA()
|
|
{
|
|
Delegates.glResizeBuffersMESA();
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Double x, Double y)
|
|
{
|
|
Delegates.glWindowPos2dMESA((Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2dvMESA((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Single x, Single y)
|
|
{
|
|
Delegates.glWindowPos2fMESA((Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2fvMESA((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int32 x, Int32 y)
|
|
{
|
|
Delegates.glWindowPos2iMESA((Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2ivMESA((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2(Int16 x, Int16 y)
|
|
{
|
|
Delegates.glWindowPos2sMESA((Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos2v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos2svMESA((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos2svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos2v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos2svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Double x, Double y, Double z)
|
|
{
|
|
Delegates.glWindowPos3dMESA((Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3dvMESA((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Single x, Single y, Single z)
|
|
{
|
|
Delegates.glWindowPos3fMESA((Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3fvMESA((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glWindowPos3iMESA((Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3ivMESA((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3(Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glWindowPos3sMESA((Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos3v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos3svMESA((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos3svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos3v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos3svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4(Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glWindowPos4dMESA((Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4v(Double* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4dvMESA((Double*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v([In, Out] Double[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v(ref Double v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4dvMESA((Double*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4(Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glWindowPos4fMESA((Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4v(Single* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4fvMESA((Single*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v([In, Out] Single[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v(ref Single v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4fvMESA((Single*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4(Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glWindowPos4iMESA((Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4v(Int32* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4ivMESA((Int32*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v([In, Out] Int32[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v(ref Int32 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4(Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glWindowPos4sMESA((Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void WindowPos4v(Int16* v)
|
|
{
|
|
unsafe { Delegates.glWindowPos4svMESA((Int16*)v); }
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v([In, Out] Int16[] v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = v)
|
|
{
|
|
Delegates.glWindowPos4svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void WindowPos4v(ref Int16 v)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* v_ptr = &v)
|
|
{
|
|
Delegates.glWindowPos4svMESA((Int16*)v_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class IBM
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, Int32* first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe { Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, Int32* first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, Int32* first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, [In, Out] Int32[] first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, [In, Out] Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, ref Int32 first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, ref Int32 first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(GL.Enums.BeginMode* mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, Int32* first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, Int32* first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, Int32* first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, [In, Out] Int32[] first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, [In, Out] Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, ref Int32 first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, ref Int32 first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM([In, Out] GL.Enums.BeginMode[] mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, Int32* first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, Int32* first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, Int32* first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, [In, Out] Int32[] first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, [In, Out] Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, ref Int32 first, Int32* count, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, ref Int32 first, [In, Out] Int32[] count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawArraysIBM(ref GL.Enums.BeginMode mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
unsafe { Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (Int32* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(GL.Enums.BeginMode* mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
fixed (Int32* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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 (Int32* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = mode)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElementsIBM([In, Out] GL.Enums.BeginMode[] mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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 (Int32* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, Int32* count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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, (Int32*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, [In, Out] Int32[] count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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 (Int32* count_ptr = count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, Int32 primcount, Int32 modestride)
|
|
{
|
|
fixed (GL.Enums.BeginMode* mode_ptr = &mode)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (Int32)primcount, (Int32)modestride);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiModeDrawElementsIBM(ref GL.Enums.BeginMode mode, ref Int32 count, GL.Enums.IBM_multimode_draw_arrays type, [In, Out] object indices, Int32 primcount, Int32 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 (Int32* count_ptr = &count)
|
|
try
|
|
{
|
|
Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
|
|
}
|
|
finally
|
|
{
|
|
indices_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ColorPointerListIBM(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glColorPointerListIBM((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void ColorPointerListIBM(Int32 size, GL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glColorPointerListIBM((Int32)size, (GL.Enums.ColorPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SecondaryColorPointerListIBM(Int32 size, GL.Enums.IBM_vertex_array_lists type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glSecondaryColorPointerListIBM((Int32)size, (GL.Enums.IBM_vertex_array_lists)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void SecondaryColorPointerListIBM(Int32 size, GL.Enums.IBM_vertex_array_lists type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glSecondaryColorPointerListIBM((Int32)size, (GL.Enums.IBM_vertex_array_lists)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void EdgeFlagPointerListIBM(Int32 stride, Boolean* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glEdgeFlagPointerListIBM((Int32)stride, (Boolean*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FogCoordPointerListIBM(GL.Enums.IBM_vertex_array_lists type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glFogCoordPointerListIBM((GL.Enums.IBM_vertex_array_lists)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void FogCoordPointerListIBM(GL.Enums.IBM_vertex_array_lists type, Int32 stride, [In, Out] object pointer, Int32 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void IndexPointerListIBM(GL.Enums.IndexPointerType type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glIndexPointerListIBM((GL.Enums.IndexPointerType)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void IndexPointerListIBM(GL.Enums.IndexPointerType type, Int32 stride, [In, Out] object pointer, Int32 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalPointerListIBM(GL.Enums.NormalPointerType type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glNormalPointerListIBM((GL.Enums.NormalPointerType)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void NormalPointerListIBM(GL.Enums.NormalPointerType type, Int32 stride, [In, Out] object pointer, Int32 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, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexCoordPointerListIBM(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glTexCoordPointerListIBM((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void TexCoordPointerListIBM(Int32 size, GL.Enums.TexCoordPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glTexCoordPointerListIBM((Int32)size, (GL.Enums.TexCoordPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexPointerListIBM(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, void* pointer, Int32 ptrstride)
|
|
{
|
|
unsafe { Delegates.glVertexPointerListIBM((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (void*)pointer, (Int32)ptrstride); }
|
|
}
|
|
|
|
public static
|
|
void VertexPointerListIBM(Int32 size, GL.Enums.VertexPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexPointerListIBM((Int32)size, (GL.Enums.VertexPointerType)type, (Int32)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class ATI
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, Int32* param)
|
|
{
|
|
unsafe { Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param); }
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [In, Out] Int32[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* param_ptr = param)
|
|
{
|
|
Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, ref Int32 param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* param_ptr = ¶m)
|
|
{
|
|
Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, Single* param)
|
|
{
|
|
unsafe { Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param); }
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [In, Out] Single[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* param_ptr = param)
|
|
{
|
|
Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void TexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, ref Single param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* param_ptr = ¶m)
|
|
{
|
|
Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [Out] Int32* param)
|
|
{
|
|
unsafe { Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param); }
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [In, Out] Int32[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* param_ptr = param)
|
|
{
|
|
Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [Out] out Int32 param)
|
|
{
|
|
param = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* param_ptr = ¶m)
|
|
{
|
|
Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (Int32*)param_ptr);
|
|
param = *param_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [Out] Single* param)
|
|
{
|
|
unsafe { Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param); }
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [In, Out] Single[] param)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* param_ptr = param)
|
|
{
|
|
Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetTexBumpParameterv(GL.Enums.ATI_envmap_bumpmap pname, [Out] out Single param)
|
|
{
|
|
param = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* param_ptr = ¶m)
|
|
{
|
|
Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (Single*)param_ptr);
|
|
param = *param_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Int32 GenFragmentShadersATI(UInt32 range)
|
|
{
|
|
return Delegates.glGenFragmentShadersATI((UInt32)range);
|
|
}
|
|
|
|
public static
|
|
Int32 GenFragmentShadersATI(Int32 range)
|
|
{
|
|
return Delegates.glGenFragmentShadersATI((UInt32)range);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindFragmentShaderATI(UInt32 id)
|
|
{
|
|
Delegates.glBindFragmentShaderATI((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BindFragmentShaderATI(Int32 id)
|
|
{
|
|
Delegates.glBindFragmentShaderATI((UInt32)id);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFragmentShaderATI(UInt32 id)
|
|
{
|
|
Delegates.glDeleteFragmentShaderATI((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void DeleteFragmentShaderATI(Int32 id)
|
|
{
|
|
Delegates.glDeleteFragmentShaderATI((UInt32)id);
|
|
}
|
|
|
|
public static
|
|
void BeginFragmentShaderATI()
|
|
{
|
|
Delegates.glBeginFragmentShaderATI();
|
|
}
|
|
|
|
public static
|
|
void EndFragmentShaderATI()
|
|
{
|
|
Delegates.glEndFragmentShaderATI();
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void PassTexCoordATI(UInt32 dst, UInt32 coord, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
public static
|
|
void PassTexCoordATI(Int32 dst, Int32 coord, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SampleMapATI(UInt32 dst, UInt32 interp, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
public static
|
|
void SampleMapATI(Int32 dst, Int32 interp, GL.Enums.ATI_fragment_shader swizzle)
|
|
{
|
|
Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (GL.Enums.ATI_fragment_shader)swizzle);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp1ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
|
|
{
|
|
Delegates.glColorFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp1ATI(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, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp2ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
|
|
{
|
|
Delegates.glColorFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp2ATI(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, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ColorFragmentOp3ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
|
|
{
|
|
Delegates.glColorFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
|
|
}
|
|
|
|
public static
|
|
void ColorFragmentOp3ATI(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, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp1ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp1ATI(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp2ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp2ATI(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, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void AlphaFragmentOp3ATI(GL.Enums.ATI_fragment_shader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
|
|
{
|
|
Delegates.glAlphaFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
|
|
}
|
|
|
|
public static
|
|
void AlphaFragmentOp3ATI(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, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetFragmentShaderConstantATI(UInt32 dst, Single* value)
|
|
{
|
|
unsafe { Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void SetFragmentShaderConstantATI(Int32 dst, Single* value)
|
|
{
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFragmentShaderConstantATI(UInt32 dst, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetFragmentShaderConstantATI(Int32 dst, [In, Out] Single[] value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFragmentShaderConstantATI(UInt32 dst, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void SetFragmentShaderConstantATI(Int32 dst, ref Single value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* value_ptr = &value)
|
|
{
|
|
Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void PNTrianglesiATI(GL.Enums.ATI_pn_triangles pname, Int32 param)
|
|
{
|
|
Delegates.glPNTrianglesiATI((GL.Enums.ATI_pn_triangles)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void PNTrianglesfATI(GL.Enums.ATI_pn_triangles pname, Single param)
|
|
{
|
|
Delegates.glPNTrianglesfATI((GL.Enums.ATI_pn_triangles)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe Int32 NewObjectBufferATI(Int32 size, void* pointer, GL.Enums.ATI_vertex_array_object usage)
|
|
{
|
|
unsafe { return Delegates.glNewObjectBufferATI((Int32)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)usage); }
|
|
}
|
|
|
|
public static
|
|
Int32 NewObjectBufferATI(Int32 size, [In, Out] 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((Int32)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)usage);
|
|
return retval;
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsObjectBufferATI(UInt32 buffer)
|
|
{
|
|
return Delegates.glIsObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
Boolean IsObjectBufferATI(Int32 buffer)
|
|
{
|
|
return Delegates.glIsObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
unsafe { Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void UpdateObjectBufferATI(Int32 buffer, Int32 offset, Int32 size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
|
|
{
|
|
{
|
|
Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, [In, Out] 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((UInt32)buffer, (UInt32)offset, (Int32)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void UpdateObjectBufferATI(Int32 buffer, Int32 offset, Int32 size, [In, Out] 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((UInt32)buffer, (UInt32)offset, (Int32)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferfvATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetObjectBufferv(UInt32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetObjectBufferv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetObjectBufferivATI((UInt32)buffer, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FreeObjectBufferATI(UInt32 buffer)
|
|
{
|
|
Delegates.glFreeObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void FreeObjectBufferATI(Int32 buffer)
|
|
{
|
|
Delegates.glFreeObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void ArrayObjectATI(GL.Enums.EnableCap array, Int32 size, GL.Enums.ATI_vertex_array_object type, Int32 stride, UInt32 buffer, UInt32 offset)
|
|
{
|
|
Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (Int32)size, (GL.Enums.ATI_vertex_array_object)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
|
|
public static
|
|
void ArrayObjectATI(GL.Enums.EnableCap array, Int32 size, GL.Enums.ATI_vertex_array_object type, Int32 stride, Int32 buffer, Int32 offset)
|
|
{
|
|
Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (Int32)size, (GL.Enums.ATI_vertex_array_object)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetArrayObjectv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VariantArrayObjectATI(UInt32 id, GL.Enums.ATI_vertex_array_object type, Int32 stride, UInt32 buffer, UInt32 offset)
|
|
{
|
|
Delegates.glVariantArrayObjectATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
|
|
public static
|
|
void VariantArrayObjectATI(Int32 id, GL.Enums.ATI_vertex_array_object type, Int32 stride, Int32 buffer, Int32 offset)
|
|
{
|
|
Delegates.glVariantArrayObjectATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVariantArrayObjectv(UInt32 id, GL.Enums.ATI_vertex_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVariantArrayObjectv(Int32 id, GL.Enums.ATI_vertex_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVariantArrayObjectivATI((UInt32)id, (GL.Enums.ATI_vertex_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1(GL.Enums.ATI_vertex_streams stream, Int16 x)
|
|
{
|
|
Delegates.glVertexStream1sATI((GL.Enums.ATI_vertex_streams)stream, (Int16)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1v(GL.Enums.ATI_vertex_streams stream, Int16* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int16[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, ref Int16 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1(GL.Enums.ATI_vertex_streams stream, Int32 x)
|
|
{
|
|
Delegates.glVertexStream1iATI((GL.Enums.ATI_vertex_streams)stream, (Int32)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1v(GL.Enums.ATI_vertex_streams stream, Int32* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int32[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, ref Int32 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1(GL.Enums.ATI_vertex_streams stream, Single x)
|
|
{
|
|
Delegates.glVertexStream1fATI((GL.Enums.ATI_vertex_streams)stream, (Single)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1v(GL.Enums.ATI_vertex_streams stream, Single* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, [In, Out] Single[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, ref Single coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1(GL.Enums.ATI_vertex_streams stream, Double x)
|
|
{
|
|
Delegates.glVertexStream1dATI((GL.Enums.ATI_vertex_streams)stream, (Double)x);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream1v(GL.Enums.ATI_vertex_streams stream, Double* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, [In, Out] Double[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream1v(GL.Enums.ATI_vertex_streams stream, ref Double coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2(GL.Enums.ATI_vertex_streams stream, Int16 x, Int16 y)
|
|
{
|
|
Delegates.glVertexStream2sATI((GL.Enums.ATI_vertex_streams)stream, (Int16)x, (Int16)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2v(GL.Enums.ATI_vertex_streams stream, Int16* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int16[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, ref Int16 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2(GL.Enums.ATI_vertex_streams stream, Int32 x, Int32 y)
|
|
{
|
|
Delegates.glVertexStream2iATI((GL.Enums.ATI_vertex_streams)stream, (Int32)x, (Int32)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2v(GL.Enums.ATI_vertex_streams stream, Int32* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int32[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, ref Int32 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2(GL.Enums.ATI_vertex_streams stream, Single x, Single y)
|
|
{
|
|
Delegates.glVertexStream2fATI((GL.Enums.ATI_vertex_streams)stream, (Single)x, (Single)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2v(GL.Enums.ATI_vertex_streams stream, Single* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, [In, Out] Single[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, ref Single coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2(GL.Enums.ATI_vertex_streams stream, Double x, Double y)
|
|
{
|
|
Delegates.glVertexStream2dATI((GL.Enums.ATI_vertex_streams)stream, (Double)x, (Double)y);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream2v(GL.Enums.ATI_vertex_streams stream, Double* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, [In, Out] Double[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream2v(GL.Enums.ATI_vertex_streams stream, ref Double coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3(GL.Enums.ATI_vertex_streams stream, Int16 x, Int16 y, Int16 z)
|
|
{
|
|
Delegates.glVertexStream3sATI((GL.Enums.ATI_vertex_streams)stream, (Int16)x, (Int16)y, (Int16)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3v(GL.Enums.ATI_vertex_streams stream, Int16* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int16[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, ref Int16 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3(GL.Enums.ATI_vertex_streams stream, Int32 x, Int32 y, Int32 z)
|
|
{
|
|
Delegates.glVertexStream3iATI((GL.Enums.ATI_vertex_streams)stream, (Int32)x, (Int32)y, (Int32)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3v(GL.Enums.ATI_vertex_streams stream, Int32* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int32[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, ref Int32 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3(GL.Enums.ATI_vertex_streams stream, Single x, Single y, Single z)
|
|
{
|
|
Delegates.glVertexStream3fATI((GL.Enums.ATI_vertex_streams)stream, (Single)x, (Single)y, (Single)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3v(GL.Enums.ATI_vertex_streams stream, Single* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Single[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, ref Single coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3(GL.Enums.ATI_vertex_streams stream, Double x, Double y, Double z)
|
|
{
|
|
Delegates.glVertexStream3dATI((GL.Enums.ATI_vertex_streams)stream, (Double)x, (Double)y, (Double)z);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream3v(GL.Enums.ATI_vertex_streams stream, Double* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Double[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream3v(GL.Enums.ATI_vertex_streams stream, ref Double coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4(GL.Enums.ATI_vertex_streams stream, Int16 x, Int16 y, Int16 z, Int16 w)
|
|
{
|
|
Delegates.glVertexStream4sATI((GL.Enums.ATI_vertex_streams)stream, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4v(GL.Enums.ATI_vertex_streams stream, Int16* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int16[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, ref Int16 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4(GL.Enums.ATI_vertex_streams stream, Int32 x, Int32 y, Int32 z, Int32 w)
|
|
{
|
|
Delegates.glVertexStream4iATI((GL.Enums.ATI_vertex_streams)stream, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4v(GL.Enums.ATI_vertex_streams stream, Int32* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int32[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, ref Int32 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4(GL.Enums.ATI_vertex_streams stream, Single x, Single y, Single z, Single w)
|
|
{
|
|
Delegates.glVertexStream4fATI((GL.Enums.ATI_vertex_streams)stream, (Single)x, (Single)y, (Single)z, (Single)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4v(GL.Enums.ATI_vertex_streams stream, Single* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, [In, Out] Single[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, ref Single coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4(GL.Enums.ATI_vertex_streams stream, Double x, Double y, Double z, Double w)
|
|
{
|
|
Delegates.glVertexStream4dATI((GL.Enums.ATI_vertex_streams)stream, (Double)x, (Double)y, (Double)z, (Double)w);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexStream4v(GL.Enums.ATI_vertex_streams stream, Double* coords)
|
|
{
|
|
unsafe { Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords); }
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, [In, Out] Double[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = coords)
|
|
{
|
|
Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexStream4v(GL.Enums.ATI_vertex_streams stream, ref Double coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = &coords)
|
|
{
|
|
Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, SByte nx, SByte ny, SByte nz)
|
|
{
|
|
Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (SByte)nx, (SByte)ny, (SByte)nz);
|
|
}
|
|
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, Byte nx, Byte ny, Byte nz)
|
|
{
|
|
Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (SByte)nx, (SByte)ny, (SByte)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, SByte* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, Byte* coords)
|
|
{
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] SByte[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Byte[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref SByte coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (SByte* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref Byte coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Byte* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (SByte*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, Int16 nx, Int16 ny, Int16 nz)
|
|
{
|
|
Delegates.glNormalStream3sATI((GL.Enums.ATI_vertex_streams)stream, (Int16)nx, (Int16)ny, (Int16)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, Int16* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int16[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref Int16 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int16* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (Int16*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, Int32 nx, Int32 ny, Int32 nz)
|
|
{
|
|
Delegates.glNormalStream3iATI((GL.Enums.ATI_vertex_streams)stream, (Int32)nx, (Int32)ny, (Int32)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, Int32* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Int32[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref Int32 coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (Int32*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, Single nx, Single ny, Single nz)
|
|
{
|
|
Delegates.glNormalStream3fATI((GL.Enums.ATI_vertex_streams)stream, (Single)nx, (Single)ny, (Single)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, Single* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Single[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref Single coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (Single*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3(GL.Enums.ATI_vertex_streams stream, Double nx, Double ny, Double nz)
|
|
{
|
|
Delegates.glNormalStream3dATI((GL.Enums.ATI_vertex_streams)stream, (Double)nx, (Double)ny, (Double)nz);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void NormalStream3v(GL.Enums.ATI_vertex_streams stream, Double* coords)
|
|
{
|
|
unsafe { Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords); }
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, [In, Out] Double[] coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = coords)
|
|
{
|
|
Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void NormalStream3v(GL.Enums.ATI_vertex_streams stream, ref Double coords)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Double* coords_ptr = &coords)
|
|
{
|
|
Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (Double*)coords_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void ClientActiveVertexStreamATI(GL.Enums.ATI_vertex_streams stream)
|
|
{
|
|
Delegates.glClientActiveVertexStreamATI((GL.Enums.ATI_vertex_streams)stream);
|
|
}
|
|
|
|
public static
|
|
void VertexBlendEnviATI(GL.Enums.ATI_vertex_streams pname, Int32 param)
|
|
{
|
|
Delegates.glVertexBlendEnviATI((GL.Enums.ATI_vertex_streams)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void VertexBlendEnvfATI(GL.Enums.ATI_vertex_streams pname, Single param)
|
|
{
|
|
Delegates.glVertexBlendEnvfATI((GL.Enums.ATI_vertex_streams)pname, (Single)param);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ElementPointerATI(GL.Enums.ATI_element_array type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glElementPointerATI((GL.Enums.ATI_element_array)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ElementPointerATI(GL.Enums.ATI_element_array type, [In, Out] 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 DrawElementArrayATI(GL.Enums.BeginMode mode, Int32 count)
|
|
{
|
|
Delegates.glDrawElementArrayATI((GL.Enums.BeginMode)mode, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElementArrayATI(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count);
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElementArrayATI(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DrawBuffersATI(Int32 n, GL.Enums.ATI_draw_buffers* bufs)
|
|
{
|
|
unsafe { Delegates.glDrawBuffersATI((Int32)n, (GL.Enums.ATI_draw_buffers*)bufs); }
|
|
}
|
|
|
|
public static
|
|
void DrawBuffersATI(Int32 n, [In, Out] GL.Enums.ATI_draw_buffers[] bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = bufs)
|
|
{
|
|
Delegates.glDrawBuffersATI((Int32)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DrawBuffersATI(Int32 n, ref GL.Enums.ATI_draw_buffers bufs)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = &bufs)
|
|
{
|
|
Delegates.glDrawBuffersATI((Int32)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
IntPtr MapObjectBufferATI(UInt32 buffer)
|
|
{
|
|
return Delegates.glMapObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
IntPtr MapObjectBufferATI(Int32 buffer)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
IntPtr retval = Delegates.glMapObjectBufferATI((UInt32)buffer);
|
|
return retval;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void UnmapObjectBufferATI(UInt32 buffer)
|
|
{
|
|
Delegates.glUnmapObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void UnmapObjectBufferATI(Int32 buffer)
|
|
{
|
|
Delegates.glUnmapObjectBufferATI((UInt32)buffer);
|
|
}
|
|
|
|
public static
|
|
void StencilOpSeparateATI(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);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void StencilFuncSeparateATI(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, Int32 @ref, UInt32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
|
|
}
|
|
|
|
public static
|
|
void StencilFuncSeparateATI(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, Int32 @ref, Int32 mask)
|
|
{
|
|
Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void VertexAttribArrayObjectATI(UInt32 index, Int32 size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, Int32 stride, UInt32 buffer, UInt32 offset)
|
|
{
|
|
Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
|
|
public static
|
|
void VertexAttribArrayObjectATI(Int32 index, Int32 size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, Int32 stride, Int32 buffer, Int32 offset)
|
|
{
|
|
unsafe
|
|
{
|
|
{
|
|
Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] Single* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] Single* @params)
|
|
{
|
|
@params = default(Single*);
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [In, Out] Single[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] out Single @params)
|
|
{
|
|
@params = default(Single);
|
|
unsafe
|
|
{
|
|
fixed (Single* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Single*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] Int32* @params)
|
|
{
|
|
unsafe { Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] Int32* @params)
|
|
{
|
|
@params = default(Int32*);
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [In, Out] Int32[] @params)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = @params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GetVertexAttribArrayObjectv(UInt32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GetVertexAttribArrayObjectv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, [Out] out Int32 @params)
|
|
{
|
|
@params = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* @params_ptr = &@params)
|
|
{
|
|
Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (Int32*)@params_ptr);
|
|
@params = *@params_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class APPLE
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void ElementPointerAPPLE(GL.Enums.APPLE_element_array type, void* pointer)
|
|
{
|
|
unsafe { Delegates.glElementPointerAPPLE((GL.Enums.APPLE_element_array)type, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void ElementPointerAPPLE(GL.Enums.APPLE_element_array type, [In, Out] 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 DrawElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 first, Int32 count)
|
|
{
|
|
Delegates.glDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 first, Int32 count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
|
|
}
|
|
|
|
public static
|
|
void DrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 first, Int32 count)
|
|
{
|
|
Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, Int32* first, Int32* count, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, Int32* first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, Int32* first, ref Int32 count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, [In, Out] Int32[] first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, [In, Out] Int32[] first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, ref Int32 first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, ref Int32 first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawElementArrayAPPLE(GL.Enums.BeginMode mode, ref Int32 first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32* first, Int32* count, Int32 primcount)
|
|
{
|
|
unsafe { Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32* first, Int32* count, Int32 primcount)
|
|
{
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32* first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32* first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32* first, ref Int32 count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, Int32* first, ref Int32 count, Int32 primcount)
|
|
{
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, [In, Out] Int32[] first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, [In, Out] Int32[] first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, [In, Out] Int32[] first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, [In, Out] Int32[] first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, [In, Out] Int32[] first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, ref Int32 first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref Int32 first, Int32* count, Int32 primcount)
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, ref Int32 first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref Int32 first, [In, Out] Int32[] count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, UInt32 start, UInt32 end, ref Int32 first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void MultiDrawRangeElementArrayAPPLE(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref Int32 first, ref Int32 count, Int32 primcount)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* first_ptr = &first)
|
|
fixed (Int32* count_ptr = &count)
|
|
{
|
|
Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFencesAPPLE(Int32 n, [Out] UInt32* fences)
|
|
{
|
|
unsafe { Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenFencesAPPLE(Int32 n, [Out] Int32* fences)
|
|
{
|
|
fences = default(Int32*);
|
|
{
|
|
Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFencesAPPLE(Int32 n, [In, Out] UInt32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFencesAPPLE(Int32 n, [In, Out] Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenFencesAPPLE(Int32 n, [Out] out UInt32 fences)
|
|
{
|
|
fences = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenFencesAPPLE(Int32 n, [Out] out Int32 fences)
|
|
{
|
|
fences = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
fences = *fences_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFencesAPPLE(Int32 n, UInt32* fences)
|
|
{
|
|
unsafe { Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteFencesAPPLE(Int32 n, Int32* fences)
|
|
{
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFencesAPPLE(Int32 n, [In, Out] UInt32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFencesAPPLE(Int32 n, [In, Out] Int32[] fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteFencesAPPLE(Int32 n, ref UInt32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteFencesAPPLE(Int32 n, ref Int32 fences)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* fences_ptr = &fences)
|
|
{
|
|
Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void SetFenceAPPLE(UInt32 fence)
|
|
{
|
|
Delegates.glSetFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
void SetFenceAPPLE(Int32 fence)
|
|
{
|
|
Delegates.glSetFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsFenceAPPLE(UInt32 fence)
|
|
{
|
|
return Delegates.glIsFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
Boolean IsFenceAPPLE(Int32 fence)
|
|
{
|
|
return Delegates.glIsFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean TestFenceAPPLE(UInt32 fence)
|
|
{
|
|
return Delegates.glTestFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
Boolean TestFenceAPPLE(Int32 fence)
|
|
{
|
|
return Delegates.glTestFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void FinishFenceAPPLE(UInt32 fence)
|
|
{
|
|
Delegates.glFinishFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
public static
|
|
void FinishFenceAPPLE(Int32 fence)
|
|
{
|
|
Delegates.glFinishFenceAPPLE((UInt32)fence);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean TestObjectAPPLE(GL.Enums.APPLE_fence @object, UInt32 name)
|
|
{
|
|
return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (UInt32)name);
|
|
}
|
|
|
|
public static
|
|
Boolean TestObjectAPPLE(GL.Enums.APPLE_fence @object, Int32 name)
|
|
{
|
|
return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (UInt32)name);
|
|
}
|
|
|
|
public static
|
|
void FinishObjectAPPLE(GL.Enums.APPLE_fence @object, Int32 name)
|
|
{
|
|
Delegates.glFinishObjectAPPLE((GL.Enums.APPLE_fence)@object, (Int32)name);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void BindVertexArrayAPPLE(UInt32 array)
|
|
{
|
|
Delegates.glBindVertexArrayAPPLE((UInt32)array);
|
|
}
|
|
|
|
public static
|
|
void BindVertexArrayAPPLE(Int32 array)
|
|
{
|
|
Delegates.glBindVertexArrayAPPLE((UInt32)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteVertexArraysAPPLE(Int32 n, UInt32* arrays)
|
|
{
|
|
unsafe { Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void DeleteVertexArraysAPPLE(Int32 n, Int32* arrays)
|
|
{
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexArraysAPPLE(Int32 n, [In, Out] UInt32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexArraysAPPLE(Int32 n, [In, Out] Int32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void DeleteVertexArraysAPPLE(Int32 n, ref UInt32 arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void DeleteVertexArraysAPPLE(Int32 n, ref Int32 arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenVertexArraysAPPLE(Int32 n, [Out] UInt32* arrays)
|
|
{
|
|
unsafe { Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays); }
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void GenVertexArraysAPPLE(Int32 n, [Out] Int32* arrays)
|
|
{
|
|
arrays = default(Int32*);
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenVertexArraysAPPLE(Int32 n, [In, Out] UInt32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (UInt32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenVertexArraysAPPLE(Int32 n, [In, Out] Int32[] arrays)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
void GenVertexArraysAPPLE(Int32 n, [Out] out UInt32 arrays)
|
|
{
|
|
arrays = default(UInt32);
|
|
unsafe
|
|
{
|
|
fixed (UInt32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
arrays = *arrays_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void GenVertexArraysAPPLE(Int32 n, [Out] out Int32 arrays)
|
|
{
|
|
arrays = default(Int32);
|
|
unsafe
|
|
{
|
|
fixed (Int32* arrays_ptr = &arrays)
|
|
{
|
|
Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
|
|
arrays = *arrays_ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
Boolean IsVertexArrayAPPLE(UInt32 array)
|
|
{
|
|
return Delegates.glIsVertexArrayAPPLE((UInt32)array);
|
|
}
|
|
|
|
public static
|
|
Boolean IsVertexArrayAPPLE(Int32 array)
|
|
{
|
|
return Delegates.glIsVertexArrayAPPLE((UInt32)array);
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void VertexArrayRangeAPPLE(Int32 length, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glVertexArrayRangeAPPLE((Int32)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void VertexArrayRangeAPPLE(Int32 length, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glVertexArrayRangeAPPLE((Int32)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void FlushVertexArrayRangeAPPLE(Int32 length, [Out] void* pointer)
|
|
{
|
|
unsafe { Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (void*)pointer); }
|
|
}
|
|
|
|
public static
|
|
void FlushVertexArrayRangeAPPLE(Int32 length, [In, Out] object pointer)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (void*)pointer_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
pointer_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static
|
|
void VertexArrayParameteriAPPLE(GL.Enums.APPLE_vertex_array_range pname, Int32 param)
|
|
{
|
|
Delegates.glVertexArrayParameteriAPPLE((GL.Enums.APPLE_vertex_array_range)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void BufferParameteriAPPLE(GL.Enums.APPLE_flush_buffer_range target, GL.Enums.APPLE_flush_buffer_range pname, Int32 param)
|
|
{
|
|
Delegates.glBufferParameteriAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (GL.Enums.APPLE_flush_buffer_range)pname, (Int32)param);
|
|
}
|
|
|
|
public static
|
|
void FlushMappedBufferRangeAPPLE(GL.Enums.APPLE_flush_buffer_range target, IntPtr offset, IntPtr size)
|
|
{
|
|
Delegates.glFlushMappedBufferRangeAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (IntPtr)offset, (IntPtr)size);
|
|
}
|
|
|
|
}
|
|
|
|
public static class GREMEDY
|
|
{
|
|
[System.CLSCompliant(false)]
|
|
public static
|
|
unsafe void StringMarkerGREMEDY(Int32 len, void* @string)
|
|
{
|
|
unsafe { Delegates.glStringMarkerGREMEDY((Int32)len, (void*)@string); }
|
|
}
|
|
|
|
public static
|
|
void StringMarkerGREMEDY(Int32 len, [In, Out] object @string)
|
|
{
|
|
System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
try
|
|
{
|
|
Delegates.glStringMarkerGREMEDY((Int32)len, (void*)@string_ptr.AddrOfPinnedObject());
|
|
}
|
|
finally
|
|
{
|
|
@string_ptr.Free();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|