Daily update on 20230505 by nitload youmu, confuse on OpenGL

This commit is contained in:
Nitload
2023-05-05 02:42:16 +08:00
parent 4dd3f4f6d1
commit 6da268056c
99 changed files with 58766 additions and 8132 deletions
Binary file not shown.
@@ -9,7 +9,7 @@ void main()
{
FILE* fpi, * fpo;
fpi = fopen("glew.h", "rt");
fpo = fopen("gl.txt", "wt");
fpo = fopen("glConst.txt", "wt");
while (!feof(fpi))
{
@@ -17,12 +17,28 @@ void main()
char str2[200] = "";
char str3[200] = "";
char str4[200] = "";
char str5[200] = "";
char str6[600] = "";
//char str5[200] = "";
//char str6[600] = "";
fscanf(fpi, "%s", str1);
fgets(str1, 200, fpi);
sscanf(str1, "%s%s%s", str2, str3, str4);
if (strcmp(str2,"#define") == 0)
{
char s1[10];
strncpy(s1, str3, 3);
s1[3] = '\0';
if (strcmp("GL_",s1)==0)
{
char s2[150];
sprintf(s2,"%s%s%s%s%s\n","public const uint ",str3,"=",str4,";");
fputs(s2, fpo);
}
}
/*
if (strcmp(str1, "GLAPI") == 0)
{
fscanf(fpi, "%s%s%s", str2, str3, str4);
@@ -42,6 +58,7 @@ void main()
fputs(s, fpo);
fputs(s1, fpo);
}
*/
}
fclose(fpi);
fclose(fpo);
@@ -70,6 +70,9 @@
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\OpenGLAssis</OutDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
@@ -0,0 +1,12 @@
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\vc143.pdb
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\vc143.idb
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consoleapplication1.obj
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consoleapplication1.ilk
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1.exe
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1.pdb
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\cl.command.1.tlog
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\cl.read.1.tlog
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\cl.write.1.tlog
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\link.command.1.tlog
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\link.read.1.tlog
d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\openglassis\consoleapplication1\consoleapplication1\x64\debug\consolea.457a0bc0.tlog\link.write.1.tlog
@@ -2,7 +2,7 @@
<Project>
<ProjectOutputs>
<ProjectOutput>
<FullPath>D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\OpenGLAssis\ConsoleApplication1\x64\Debug\ConsoleApplication1.exe</FullPath>
<FullPath>D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\OpenGLAssis\ConsoleApplication1.exe</FullPath>
</ProjectOutput>
</ProjectOutputs>
<ContentFiles />
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+1 -1
View File
@@ -1,5 +1,5 @@
/*
** The OpenGL Extension Wrangler Library
** The OpenGL Extension Wrangler Librarypromote
** Copyright (C) 2008-2017, Nigel Stewart <nigels[]users sourceforge net>
** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
-8
View File
@@ -7,12 +7,4 @@ __m128 sqrtss(float m)
.m128_f32[0]=m
};
return _mm_sqrt_ss(mCache);
}
void main()
{
float m = 25.0f;
scanf_s("%f",&m);
printf("%f",sqrtss(m).m128_f32[0]);
}
@@ -40,7 +40,7 @@
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
@@ -1,2 +1,2 @@
PlatformToolSet=v143:VCToolArchitecture=Native64Bit:VCToolsVersion=14.33.31629:TargetPlatformVersion=10.0.19041.0:
Debug|x64|D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\Asm\|
Debug|x64|D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\|
File diff suppressed because it is too large Load Diff
Binary file not shown.
Binary file not shown.
@@ -1,27 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Graphic
{
/// <summary>
/// Provides methods for querying available functions in a bindings context.
/// </summary>
public interface IBindingsContext
{
/// <summary>
/// Retrieves an unmanaged function pointer to the specified function on the specified bindings context.
/// </summary>
/// <param name="procName">An ASCII-encoded string that defines the name of the function.</param>
/// <returns>
/// A <see cref="System.IntPtr"/> that contains the address of procName or IntPtr.Zero,
/// if the function is not supported by the drivers.
/// </returns>
/// <remarks>
/// Note: some drivers are known to return non-zero values for unsupported functions.
/// Typical values include 1 and 2 - inheritors are advised to check for and ignore these
/// values.
/// </remarks>
IntPtr GetProcAddress(string procName);
}
}
@@ -1,171 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Graphic.GL
{
/// <summary>
/// Provides a common foundation for all flat API bindings and implements the extension loading interface.
/// </summary>
public abstract class BindingsBase
{
/// <summary>
/// Constructs a new BindingsBase instance.
/// </summary>
public BindingsBase()
{
}
/// <summary>
/// Marshals a pointer to a null-terminated byte array to a new <c>System.String</c>.
/// This method supports OpenTK and is not intended to be called by user code.
/// </summary>
/// <param name="ptr">A pointer to a null-terminated byte array.</param>
/// <returns>
/// A <c>System.String</c> with the data from <paramref name="ptr"/>.
/// </returns>
protected static string MarshalPtrToString(IntPtr ptr)
{
if (ptr == IntPtr.Zero)
{
throw new ArgumentException("ptr");
}
unsafe
{
sbyte* str = (sbyte*)ptr;
int len = 0;
while (*str != 0)
{
++len;
++str;
}
return new string((sbyte*)ptr, 0, len, Encoding.UTF8);
}
}
/// <summary>
/// Marshal a <c>System.String</c> to unmanaged memory.
/// The resulting string is encoded in UTF8 and must be freed
/// with <c>FreeStringPtr</c>.
/// </summary>
/// <param name="str">The <c>System.String</c> to marshal.</param>
/// <returns>
/// An unmanaged pointer containing the marshalled string.
/// This pointer must be freed with <c>FreeStringPtr</c>
/// </returns>
protected static IntPtr MarshalStringToPtr(string str)
{
if (string.IsNullOrEmpty(str))
{
return IntPtr.Zero;
}
// Allocate a buffer big enough to hold the marshalled string.
// GetMaxByteCount() appears to allocate space for the final NUL
// character, but allocate an extra one just in case (who knows
// what old Mono version would do here.)
int max_count = Encoding.UTF8.GetMaxByteCount(str.Length) + 1;
IntPtr ptr = Marshal.AllocHGlobal(max_count);
if (ptr == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
// Pin the managed string and convert it to UTF8 using
// the pointer overload of System.Encoding.UTF8.GetBytes().
unsafe
{
fixed (char* pstr = str)
{
int actual_count = Encoding.UTF8.GetBytes(pstr, str.Length, (byte*)ptr, max_count);
Marshal.WriteByte(ptr, actual_count, 0); // Append '\0' at the end of the string
return ptr;
}
}
}
/// <summary>
/// Frees a marshalled string that allocated by <c>MarshalStringToPtr</c>.
/// </summary>
/// <param name="ptr">An unmanaged pointer allocated with <c>MarshalStringToPtr</c></param>
protected static void FreeStringPtr(IntPtr ptr)
{
Marshal.FreeHGlobal(ptr);
}
/// <summary>
/// Marshals a <c>System.String</c> array to unmanaged memory by calling
/// Marshal.AllocHGlobal for each element.
/// </summary>
/// <returns>An unmanaged pointer to an array of null-terminated strings</returns>
/// <param name="str_array">The string array to marshal.</param>
protected static IntPtr MarshalStringArrayToPtr(string[] str_array)
{
IntPtr ptr = IntPtr.Zero;
if (str_array != null && str_array.Length != 0)
{
ptr = Marshal.AllocHGlobal(str_array.Length * IntPtr.Size);
if (ptr == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
int i = 0;
try
{
for (i = 0; i < str_array.Length; i++)
{
IntPtr str = MarshalStringToPtr(str_array[i]);
Marshal.WriteIntPtr(ptr, i * IntPtr.Size, str);
}
}
catch (OutOfMemoryException)
{
for (i = i - 1; i >= 0; --i)
{
Marshal.FreeHGlobal(Marshal.ReadIntPtr(ptr, i * IntPtr.Size));
}
Marshal.FreeHGlobal(ptr);
throw;
}
}
return ptr;
}
/// <summary>
/// Frees a marshalled string that allocated by <c>MarshalStringArrayToPtr</c>.
/// </summary>
/// <param name="ptr">An unmanaged pointer allocated with <c>MarshalStringArrayToPtr</c></param>
/// <param name="length">The length of the string array.</param>
protected static void FreeStringArrayPtr(IntPtr ptr, int length)
{
for (int i = 0; i < length; i++)
{
Marshal.FreeHGlobal(Marshal.ReadIntPtr(ptr, i * IntPtr.Size));
}
Marshal.FreeHGlobal(ptr);
}
private protected static void InitializeDummyEntryPoints(IntPtr[] entryPoints)
{
var ptr = Marshal.GetFunctionPointerForDelegate(UninitializedDelegate);
for (var i = 0; i < entryPoints.Length; i++)
{
entryPoints[i] = ptr;
}
}
private static readonly Action UninitializedDelegate = Uninitialized;
private static void Uninitialized()
{
throw new InvalidOperationException("You need to initialize the OpenGL binding first by calling LoadBindings() or creating a compatible OpenGL window.");
}
}
}
-16
View File
@@ -1,16 +0,0 @@
using System;
namespace StgSharp.Graphic.GL
{
/// <summary>
/// A delegate used to receive debug information.
/// </summary>
/// <param name="source">The source of the callback.</param>
/// <param name="type">The type of the callback.</param>
/// <param name="id">The ID of the callback.</param>
/// <param name="severity">The severity of the callback.</param>
/// <param name="length">The length of the callback message.</param>
/// <param name="message">A pointer to the callback message.</param>
/// <param name="userParam">A user supplied pointer that will be passed on each callback.</param>
public delegate void DebugProc(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam);
}
@@ -1,27 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Graphic.GL
{
public struct CombinerPortionNV { }
public struct DebugProcAmd { }
public struct DebugProcArb { }
public struct DebugProcKhr { }
public struct ElementPointerTypeATI { }
public struct FragmentLightParameterSGIX { }
public struct IglooFunctionSelectSGIX { }
public struct IndexFunctionEXT { }
public struct MapTypeNV { }
public struct MatrixIndexPointerTypeARB { }
public struct ProgramFormat { }
public struct ProgramStringProperty { }
public struct ProgramTarget { }
public struct ReplacementCodeTypeSUN { }
public struct SecondaryColorPointerTypeIBM { }
public struct Struct_cl_context { }
public struct Struct_cl_event { }
public struct VertexShaderWriteMaskEXT { }
public struct VertexWeightPointerTypeEXT { }
public struct WeightPointerTypeARB { }
}
@@ -1,33 +0,0 @@
using System.Runtime.InteropServices;
namespace StgSharp.Graphic.GL
{
/// <summary>
/// Contains the library name of OpenGL.
/// </summary>
internal class LibraryNameContainer
{
/// <inheritdoc />
public static string Linux => "libGL.so";
/// <inheritdoc />
public static string MacOS => "/System/Library/Frameworks/OpenGL.framework/OpenGL";
/// <inheritdoc />
public static string Android => "libGL.so";
/// <inheritdoc />
public static string IOS => "/System/Library/Frameworks/OpenGL.framework/OpenGL";
/// <inheritdoc />
public static string Windows => "opengl32.dll";
public static string GetLibraryNameForCurrentPlatform()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) return Linux;
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) return Windows;
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) return MacOS;
else return "unknown platform";
}
}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -1,15 +0,0 @@
namespace StgSharp.Graphic.Input
{
public enum HidConsumerUsage : ushort
{
/// <summary>
/// General consumer control device.
/// </summary>
ConsumerControl = 0x01,
/// <summary>
/// Set the horizontal offset of the display in the document.
/// </summary>
ACPan = 0x0238,
}
}
@@ -1,258 +0,0 @@
namespace StgSharp.Graphic.Input
{
public enum HidGenericDesktopUsage : ushort
{
/// <summary>
/// A collection of axes that generates a value to direct, indicate, or point
/// user intentions to an application.
/// </summary>
Pointer = 0x01,
/// <summary>
/// A hand-held, button-activated input device that when rolled along a flat surface,
/// directs an indicator to move correspondingly about a computer screen, allowing the
/// operator to move the indicator freely in select operations or to manipulate text or graphics.
/// </summary>
Mouse = 0x02,
// 0x03 // Reserved
/// <summary>
/// A manual control or cursor device.
/// </summary>
Joystick = 0x04,
/// <summary>
/// A manual control or cursor device.
/// </summary>
GamePad = 0x05,
/// <summary>
/// The primary computer input device.
/// </summary>
Keyboard = 0x06,
/// <summary>
/// Any keyboard configuration that does not meet the minimum requirements of the Boot Keyboard.
/// </summary>
Keypad = 0x07,
/// <summary>
/// An input device used to orient eyepoints and or objects in 3 dimensional space.
/// </summary>
MultiAxisController = 0x08,
// 0x09 - 0x2F // Reserved
/// <summary>
/// A linear translation in the X direction.
/// </summary>
X = 0x30,
/// <summary>
/// A linear translation in the Y direction.
/// </summary>
Y = 0x31,
/// <summary>
/// A linear translation in the Z direction.
/// </summary>
Z = 0x32,
/// <summary>
/// A rotation about the X axis. Angular position report values follow the righthand rule.
/// </summary>
RotationX = 0x33,
/// <summary>
/// A rotation about the Y axis. Angular position report values follow the righthand rule.
/// </summary>
RotationY = 0x34,
/// <summary>
/// A rotation about the Z axis. Angular position report values follow the righthand rule.
/// </summary>
RotationZ = 0x35,
/// <summary>
/// A linear control for generating a variable value, normally in the form of a thumb slide in a slot.
/// </summary>
Slider = 0x36,
/// <summary>
/// A rotary control for generating a variable value,
/// normally in the form of a knob spun by the index finger and thumb.
/// </summary>
Dial = 0x37,
/// <summary>
/// A rotary control for generating a variable value, normally rolled, unlike a dial.
/// </summary>
Wheel = 0x38,
/// <summary>
/// A specialized mechanical configuration of switches generating a variable value with a null state.
/// </summary>
Hatswitch = 0x39,
/// <summary>
/// Used with buffered –byte data to indicate the number of valid bytes in the buffered-byte field.
/// </summary>
CountedBuffer = 0x3A,
/// <summary>
/// Defines a report field that indicates the number of meaningful data bytes
/// in an associated buffered-byte field.
/// </summary>
ByteCount = 0x3B,
/// <summary>
/// Enables the generation of a USB remote wakeup when the device detects motion.
/// </summary>
MotionWakeup = 0x3C,
/// <summary>
/// Session start button.
/// </summary>
Start = 0x3D,
/// <summary>
/// Application option select button.
/// </summary>
Select = 0x3E,
// 0x3F // Reserved
/// <summary>
/// A vector in the X direction.
/// </summary>
VectorX = 0x40,
/// <summary>
/// A vector in the Y direction.
/// </summary>
VectorY = 0x41,
/// <summary>
/// A vector in the Z direction.
/// </summary>
VectorZ = 0x42,
/// <summary>
/// A vector in the X direction relative to the body of an object.
/// </summary>
VectorXBodyRelative = 0x43,
/// <summary>
/// A vector in the Y direction relative to the body of an object.
/// </summary>
VectorYBodyRelative = 0x44,
/// <summary>
/// A vector in the Z direction relative to the body of an object.
/// </summary>
VectorZBodyRelative = 0x45,
/// <summary>
/// A non oriented vector or value.
/// </summary>
VectorNonOriented = 0x46,
// 0x47 - 0x7F // Reserved
/// <summary>
/// An application-level collection that contains system-software-specific usages.
/// </summary>
SystemControl = 0x80,
/// <summary>
/// Asserted when the intended action is to initiate system-wide power down now from
/// Full Power or Sleep states.
/// </summary>
SystemPowerDown = 0x81,
/// <summary>
/// Asserted when the intended action is to initiate system-wide low power mode now.
/// </summary>
SystemSleep = 0x82,
/// <summary>
/// Asserted when the intended action is to initiate system-wide Full Power state now.
/// </summary>
SystemWakeUp = 0x83,
/// <summary>
/// Evokes a context-sensitive menu.
/// </summary>
SystemContextMenu = 0x84,
/// <summary>
/// Evokes the OS main-level selection menu.
/// </summary>
SystemMainMenu = 0x85,
/// <summary>
/// Displays an application-specific menu.
/// </summary>
SystemAppMenu = 0x86,
/// <summary>
/// Displays the help menu.
/// </summary>
SystemMenuHelp = 0x87,
/// <summary>
/// Exits a menu.
/// </summary>
SystemMenuExit = 0x88,
/// <summary>
/// Selects a menu item.
/// </summary>
SystemMenuSelect = 0x89,
/// <summary>
/// Menu select right.
/// </summary>
SystemMenuRight = 0x8A,
/// <summary>
/// Menu select left.
/// </summary>
SystemMenuLeft = 0x8B,
/// <summary>
/// Menu select up.
/// </summary>
SystemMenuUp = 0x8C,
/// <summary>
/// Menu select down.
/// </summary>
SystemMenuDown = 0x8D,
// 0x8E - 0x8F // Reserved
/// <summary>
/// Indicates that top of a Direction Pad is pressed.
/// </summary>
DPadUp = 0x90,
/// <summary>
/// Indicates that bottom of a Direction Pad is pressed
/// </summary>
DPadDown = 0x91,
/// <summary>
/// Indicates that right side of a Direction Pad is pressed
/// </summary>
DPadRight = 0x92,
/// <summary>
/// Indicates that left side of a Direction Pad is pressed
/// </summary>
DPadLeft = 0x93,
// 0x94 - 0xFFFF // Reserved
}
}
@@ -1,57 +0,0 @@
using System.Diagnostics;
namespace StgSharp.Graphic.Input
{
public static class HidHelper
{
/// <summary>
/// Translates a generic HID usage value to a specific joystick axis for the specified <see cref="HidPage"/>.
/// </summary>
/// <param name="page">The HID usage page.</param>
/// <param name="usage">The generic usage value.</param>
/// <returns>An <see cref="int"/> that maps the HID usage value to a joystick axis.</returns>
public static int TranslateJoystickAxis(HidPage page, int usage)
{
switch (page)
{
case HidPage.GenericDesktop:
switch ((HidGenericDesktopUsage)usage)
{
case HidGenericDesktopUsage.X:
return 0;
case HidGenericDesktopUsage.Y:
return 1;
case HidGenericDesktopUsage.Z:
return 2;
case HidGenericDesktopUsage.RotationZ:
return 3;
case HidGenericDesktopUsage.RotationX:
return 4;
case HidGenericDesktopUsage.RotationY:
return 5;
case HidGenericDesktopUsage.Slider:
return 6;
case HidGenericDesktopUsage.Dial:
return 7;
case HidGenericDesktopUsage.Wheel:
return 8;
}
break;
case HidPage.Simulation:
switch ((HidSimulationUsage)usage)
{
case HidSimulationUsage.Rudder:
return 9;
case HidSimulationUsage.Throttle:
return 10;
}
break;
}
Debug.Print($"[Input] Unknown axis with HID page/usage {page}/{usage}");
return 0;
}
}
}
-170
View File
@@ -1,170 +0,0 @@
namespace StgSharp.Graphic.Input
{
public enum HidPage : ushort
{
/// <summary>
/// This page describes an undefined usage.
/// </summary>
Undefined = 0x00,
/// <summary>
/// This page describes generic desktop controls.
/// </summary>
GenericDesktop = 0x01,
/// <summary>
/// This page provides detailed descriptions of the usages employed by simulation devices.
/// </summary>
Simulation = 0x02,
/// <summary>
/// Describes virtual reality controls. The usages depend on designators to identify the individual controls.
/// </summary>
VR = 0x03,
/// <summary>
/// This page describes sport controls.
/// </summary>
Sport = 0x04,
/// <summary>
/// This page describes game controls.
/// </summary>
Game = 0x05,
/// <summary>
/// This page provides usage definitions for controls that can be on any type of device.
/// </summary>
GenericDevice = 0x06,
/// <summary>
/// This page is for key codes to be used in implementing a USB keyboard.
/// </summary>
/// <remarks>
/// The usage type of all key codes is Selectors (Sel), except for the modifier keys 'Keyboard Left Control'
/// (0x224) to 'Keyboard Right GUI' (0x231) which are Dynamic Flags (DV).
/// </remarks>
KeyboardOrKeypad = 0x07,
/// <summary>
/// This page describes an LED or indicator that is implemented as an On/Off control (OOC)
/// using the "Single button toggle" mode,
/// where a value of 1 will turn on the indicator, and a value of 0 will turn it off.
/// </summary>
LEDs = 0x08,
/// <summary>
/// This page describes a set of buttons which can be defined as Sel, OOC, MC or OSC depending on
/// the context of their declaration.
/// </summary>
Button = 0x09,
/// <summary>
/// This page allows multiple instances of a control or sets of controls to be declared without
/// requiring indiviual enumeration in the native usage page.
/// </summary>
Ordinal = 0x0A,
/// <summary>
/// This page defines the keytop and control usages for telephony devices.
/// </summary>
/// <remarks>
/// Note that in many cases usage definitions are intentionally vague, since it is assumed that
/// the controls are interpreted by the telephone software application.
/// </remarks>
Telephony = 0x0B,
/// <summary>
/// This page describes application-specific controls.
/// They only affect a specific device, not the system as a whole.
/// </summary>
Consumer = 0x0C,
/// <summary>
/// This section provides detailed descriptions of the usages employed by Digitizer Devices.
/// </summary>
Digitizer = 0x0D,
// 0x0E // Reserved
/// <summary>
/// Describes force feedback and related devices.
/// </summary>
PID = 0x0F,
/// <summary>
/// The Unicode page directly maps to the two-octet form defined in the Unicode Standard.
/// </summary>
Unicode = 0x10,
// 0x11 - 0x13 // Reserved
/// <summary>
/// The Alphanumeric display page is intended for use by simple alphanumeric
/// displays that are used on consumer devices.
/// </summary>
AlphanumericDisplay = 0x14,
// 0x15 - 0x3F // Reserved
/// <summary>
/// This page provides usage definitions for medical instruments.
/// </summary>
MedicalInstruments = 0x40,
// 0x41 - 0x7F
// 0x80 - 0x83 // USB Device Class Definition for Monitor Devices
/// <summary>
/// Power device page.
/// </summary>
PowerDevice = 0x84,
/// <summary>
/// Battery system page.
/// </summary>
BatterySystem = 0x85,
// 0x86 - 0x87 // USB Device Class Definition for Power Devices (also includes 0x84 and 0x85)
// 0x88 - 0x8B // Reserved
/// <summary>
/// This page describes the USB Device Class definition for a bar code scanner ("Point of Sale" device).
/// </summary>
BarCodeScanner = 0x8C,
/// <summary>
/// This page describes the USB Device Class definition for a scale ("Point of Sale" device).
/// </summary>
Scale = 0x8D,
/// <summary>
/// This page describes the USB Device Class definition for a magnetic stripe reading device
/// ("Point of Sale" device).
/// </summary>
MagneticStripeReader = 0x8E,
// 0x8F // Reserved Point of Sale pages
/// <summary>
/// This page describes the USB Device Class definition for "Image Class Devices".
/// </summary>
CameraControl = 0x90,
/// <summary>
/// This page describes the OAAF definitions for arcade and coinop related devices.
/// </summary>
Arcade = 0x91,
// 0x92 - 0xFEFF // Reserved
/// <summary>
/// Marks the beginning of vendor-defined usage pages.
/// </summary>
VendorDefinedStart = 0xFF00,
// 0xFF00 - 0xFFFF // Vendor-defined
}
}
@@ -1,288 +0,0 @@
using StgSharp.Graphic;
using System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Graphic.Input
{
public enum HidSimulationUsage : ushort
{
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses the
/// standard controls found on an airplane.
/// </summary>
FlightSimulationDevice = 0x01,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses the
/// standard controls found in an automobile or truck.
/// </summary>
AutomobileSimulationDevice = 0x02,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses
/// standard controls found in a tank or a treaded vehicle.
/// </summary>
TankSimulationDevice = 0x03,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses
/// standard controls found on a spaceship.
/// </summary>
SpaceshipSimulationDevice = 0x04,
/// <summary>
/// Allows a device to be generally classified as one that uses the standard controls of a submarine.
/// </summary>
SubmarineSimulationDevice = 0x05,
/// <summary>
/// Allows a device to be generally classified as one that uses the standard controls of a sailboat.
/// </summary>
SailingSimulationDevice = 0x06,
/// <summary>
/// Allows a device to be generally classified as one that uses the standard controls of a motorcycle.
/// </summary>
MotorcycleSimulationDevice = 0x07,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses
/// standard controls found on a sports simulation device.
/// </summary>
SportsSimulationDevice = 0x08,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses
/// standard controls found on an airplane.
/// </summary>
AirplaneSimulationDevice = 0x09,
/// <summary>
/// This usage definition allows a device to be generally classified as one that uses
/// standard controls found on a helicopter.
/// </summary>
HelicopterSimulationDevice = 0x0A,
/// <summary>
/// Allows a device to be generally classified as one that uses the standard control of a magic carpet.
/// </summary>
MagicCarpetSimulationDevice = 0x0B,
/// <summary>
/// Allows a device to be generally classified as one that uses the standard controls of a bicycle.
/// </summary>
BicycleSimulationDevice = 0x0C,
// 0x0D - 0x1F // Reserved
/// <summary>
/// A Flight Control Stick controls the Pitch and Roll of an airplane.
/// </summary>
FlightControlStick = 0x20,
/// <summary>
/// A Flight Stick defines a class of device commonly used for flight simulator games.
/// </summary>
FlightStick = 0x21,
/// <summary>
/// This control is specifically for a helicopter.<para/>
/// A cyclic control is a stick between the pilot’s legs that moves in two axes.
/// </summary>
CyclicControl = 0x22,
/// <summary>
/// This control is specifically for a helicopter.<para/>
/// Cyclic Trim allows fine adjustment of the cyclic position in two dimensions.
/// </summary>
CyclicTrim = 0x23,
/// <summary>
/// A flight yoke (also called a control wheel) controls the pitch and roll of an airplane.
/// </summary>
FlightYoke = 0x24,
/// <summary>
/// A device for controlling the direction and velocity of a vehicle that is driven by tracks.
/// </summary>
TrackControl = 0x25,
// 0x26 - 0xAF // Reserved
/// <summary>
/// An aileron is one of two movable flaps on the wings of an airplane that can be used
/// to control the plane’s rolling and banking movements.
/// </summary>
Aileron = 0xB0,
/// <summary>
/// Allows fine adjustment of the Aileron position.
/// </summary>
AileronTrim = 0xB1,
/// <summary>
/// This control mechanically behaves the same as rudder pedals.
/// </summary>
AntiTorqueControl = 0xB2,
/// <summary>
/// This control enables or disables an airplane’s autopilot.
/// </summary>
AutopilotEnable = 0xB3,
/// <summary>
/// Chaff is used to reflect electromagnetic energy as a radar countermeasure.
/// </summary>
ChaffRelease = 0xB4,
/// <summary>
/// This control is specifically for a helicopter.
/// It controls the vertical acceleration or lift of the helicopter.
/// </summary>
CollectiveControl = 0xB5,
/// <summary>
/// A flap that can be extended on an aircraft to increase drag and reduce the speed of descent.
/// </summary>
DiveBrake = 0xB6,
/// <summary>
/// A pushbutton that enables electronic countermeasures.
/// </summary>
ElectronicCountermeasures = 0xB7,
/// <summary>
/// A movable control surface, usually attached to the horizontal stabilizer of an aircraft,
/// that is used to produce motion up or down.
/// </summary>
Elevator = 0xB8,
/// <summary>
/// Elevator Trim allows fine adjustment of the Elevator position.
/// </summary>
ElevatorTrim = 0xB9,
/// <summary>
/// The zero position is centered, positive values turn right, and negative values turn left.
/// </summary>
Rudder = 0xBA,
/// <summary>
/// A valve that regulates the flow of a fluid, such as the valve in an internal-combustion engine
/// that controls the amount of vaporized fuel entering the cylinders.
/// </summary>
Throttle = 0xBB,
/// <summary>
/// Typically this is a two-position pushbutton where the first position enables communications with the
/// crew and the second position enables the transmitter for communication external to the plane.
/// </summary>
FlightCommunications = 0xBC,
/// <summary>
/// A flare is a device that produces a bright light for signaling, illumination, identification,
/// or heat for infrared missile countermeasures.
/// </summary>
FlareRelease = 0xBD,
/// <summary>
/// A control for raising or lowering an airplane’s landing gear.
/// </summary>
LandingGear = 0xBE,
/// <summary>
/// A device for slowing or stopping the motion of an airplane when it is on the ground.
/// </summary>
ToeBrake = 0xBF,
/// <summary>
/// A lever pressed by the finger to release or activate a mechanism, typically used to discharge a firearm.
/// </summary>
Trigger = 0xC0,
/// <summary>
/// This device is normally a covered toggle switch that must be selected to enable the weapons system.
/// </summary>
WeaponsArm = 0xC1,
/// <summary>
/// This device can either be a pushbutton that steps through the available weapons or
/// a radio button that selects them individually.
/// </summary>
WeaponsSelect = 0xC2,
/// <summary>
/// Wing flap controls are usually powered either hydraulically or by electric motors,
/// and are used for low-speed control of an airplane.
/// </summary>
WingFlaps = 0xC3,
/// <summary>
/// A device, especially the gas pedal of a motor vehicle, for increasing speed.
/// </summary>
Accelerator = 0xC4,
/// <summary>
/// A device for slowing or stopping motion, as of a vehicle, especially by contact friction.
/// </summary>
Brake = 0xC5,
/// <summary>
/// A device for disengaging the transmission of a vehicle to allow shifting of gears.
/// </summary>
Clutch = 0xC6,
/// <summary>
/// A device for shifting gears in a vehicle.
/// </summary>
Shifter = 0xC7,
/// <summary>
/// A steering wheel is a single degree-of-freedom device that rotates about an axis.
/// </summary>
Steering = 0xC8,
/// <summary>
/// This control determines the right-to-left positioning of the tank turret.
/// </summary>
TurretDirection = 0xC9,
/// <summary>
/// This control determines the elevation of the gun barrel in a turret.
/// </summary>
BarrelElevation = 0xCA,
/// <summary>
/// Dive planes control the vertical ascent or descent of the submarine under power.
/// </summary>
DivePlane = 0xCB,
/// <summary>
/// Ballast controls the vertical ascent or descent of the submarine.
/// </summary>
Ballast = 0xCC,
/// <summary>
/// A foot-operated assembly of pedals attached to a crank that is used for powering a bicycle.
/// </summary>
BicycleCrank = 0xCD,
/// <summary>
/// A steering control, held in both hands, for a motorcycle or bicycle.
/// </summary>
HandleBars = 0xCE,
/// <summary>
/// Engages the front brake of the motorcycle to slow the vehicle.
/// </summary>
FrontBrake = 0xCF,
/// <summary>
/// Engages the rear brake of the motorcycle to slow the vehicle.
/// </summary>
RearBrake = 0xD0,
// 0xD1 - 0xFFFF // Reserved
}
}
+13
View File
@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Graphics
{
public static class GLinit
{
[DllImport("opengl32.dll", ExactSpelling = false, EntryPoint = "wglGetProcAddress", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
internal static extern IntPtr wglGetProcAddress(string funcName);
}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+15
View File
@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Graphics
{
internal class build_in
{
internal static Dictionary<int, GLexFunc_table> ExtensionFunctionsTableDictionary = new Dictionary<int, GLexFunc_table>();
internal static Dictionary<int, List<string>> MissingExtensionFunctionsDictionary = new Dictionary<int, List<string>>();
internal static GLexFunc_table ExtensionFunctionsForCurrent;
}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,607 @@
using System;
namespace StgSharp.Graphics
{
/// <summary>
/// OpenGL接口函数封装类
/// </summary>
public partial class gl
{
internal delegate void glDrawRangeElements(uint mode, uint start, uint end, int count, uint type, IntPtr indices);
internal delegate void glTexImage3D(uint target, int level, int internalformat, int width, int height, int depth, int border, uint format, uint type, IntPtr pixels);
internal delegate void glTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, IntPtr pixels);
internal delegate void glCopyTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
internal delegate void glActiveTexture(uint texture);
internal delegate void glSampleCoverage(float value, bool invert);
internal delegate void glCompressedTexImage3D(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, IntPtr data);
internal delegate void glCompressedTexImage2D(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, IntPtr data);
internal delegate void glCompressedTexImage1D(uint target, int level, uint internalformat, int width, int border, int imageSize, IntPtr data);
internal delegate void glCompressedTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, IntPtr data);
internal delegate void glCompressedTexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, IntPtr data);
internal delegate void glCompressedTexSubImage1D(uint target, int level, int xoffset, int width, uint format, int imageSize, IntPtr data);
internal delegate void glGetCompressedTexImage(uint target, int level, IntPtr img);
internal delegate void glBlendFuncSeparate(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha);
internal delegate void glMultiDrawArrays(uint mode, int[] first, int[] count, int drawcount);
internal delegate void glMultiDrawElements(uint mode, int[] count, uint type, IntPtr[] indices, int drawcount);
internal delegate void glPointParameterf(uint pname, float Param);
internal delegate void glPointParameterfv(uint pname, float[] Params);
internal delegate void glPointParameteri(uint pname, int Param);
internal delegate void glPointParameteriv(uint pname, int[] Params);
internal delegate void glBlendColor(float red, float green, float blue, float alpha);
internal delegate void glBlendEquation(uint mode);
internal delegate void glGenQueries(int n, uint[] ids);
internal delegate void glDeleteQueries(int n, uint[] ids);
internal delegate bool glIsQuery(uint id);
internal delegate void glBeginQuery(uint target, uint id);
internal delegate void glEndQuery(uint target);
internal delegate void glGetQueryiv(uint target, uint pname, int[] Params);
internal delegate void glGetQueryObjectiv(uint id, uint pname, int[] Params);
internal delegate void glGetQueryObjectuiv(uint id, uint pname, uint[] Params);
internal delegate void glBindBuffer(uint target, uint buffer);
internal delegate void glDeleteBuffers(int n, uint[] buffers);
internal delegate void glGenBuffers(int n, uint[] buffers);
internal delegate bool glIsBuffer(uint buffer);
internal delegate void glBufferData(uint target, int size, IntPtr data, uint usage);
internal delegate void glBufferSubData(uint target, int offset, int size, IntPtr data);
internal delegate void glGetBufferSubData(uint target, int offset, int size, IntPtr data);
internal delegate void glMapBuffer(uint target, uint access);
internal delegate bool glUnmapBuffer(uint target);
internal delegate void glGetBufferParameteriv(uint target, uint pname, int[] Params);
internal delegate void glGetBufferPointerv(uint target, uint pname, IntPtr[] Params);
internal delegate void glBlendEquationSeparate(uint modeRGB, uint modeAlpha);
internal delegate void glDrawBuffers(int n, uint[] bufs);
internal delegate void glStencilOpSeparate(uint face, uint sfail, uint dpfail, uint dppass);
internal delegate void glStencilFuncSeparate(uint face, uint func, int Ref, uint mask);
internal delegate void glStencilMaskSeparate(uint face, uint mask);
internal delegate void glAttachShader(uint program, uint shader);
internal delegate void glBindAttribLocation(uint program, uint index, byte[] name);
internal delegate void glCompileShader(uint shader);
internal delegate uint glCreateProgram();
internal delegate uint glCreateShader(uint type);
internal delegate void glDeleteProgram(uint program);
internal delegate void glDeleteShader(uint shader);
internal delegate void glDetachShader(uint program, uint shader);
internal delegate void glDisableVertexAttribArray(uint index);
internal delegate void glEnableVertexAttribArray(uint index);
internal delegate void glGetActiveAttrib(uint program, uint index, int bufSize, out int length,out int size, out uint type, byte[] name);
internal delegate void glGetActiveUniform(uint program, uint index, int bufSize, out int length, out int size, out uint type, byte[] name);
internal delegate void glGetAttachedShaders(uint program, int maxCount,out int count, uint[] shaders);
internal delegate int glGetAttribLocation(uint program, byte[] name);
internal delegate void glGetProgramiv(uint program, uint pname, int[] Params);
internal delegate void glGetProgramInfoLog(uint program, int bufSize, out int length, byte[] infoLog);
internal delegate void glGetShaderiv(uint shader, uint pname, int[] Params);
internal delegate void glGetShaderInfoLog(uint shader, int bufSize,out int length, byte[] infoLog);
internal delegate void glGetShaderSource(uint shader, int bufSize, out int length, byte[] source);
internal delegate int glGetUniformLocation(uint program, byte[] name);
internal delegate void glGetUniformfv(uint program, int location, float[] Params);
internal delegate void glGetUniformiv(uint program, int location, int[] Params);
internal delegate void glGetVertexAttribdv(uint index, uint pname, double[] Params);
internal delegate void glGetVertexAttribfv(uint index, uint pname, float[] Params);
internal delegate void glGetVertexAttribiv(uint index, uint pname, int[] Params);
internal delegate void glGetVertexAttribPointerv(uint index, uint pname, IntPtr[] pointer);
internal delegate bool glIsProgram(uint program);
internal delegate bool glIsShader(uint shader);
internal delegate void glLinkProgram(uint program);
internal delegate void glShaderSource(uint shader, int count, IntPtr[] str, IntPtr length);
internal delegate void glUseProgram(uint program);
internal delegate void glUniform1f(int location, float v0);
internal delegate void glUniform2f(int location, float v0, float v1);
internal delegate void glUniform3f(int location, float v0, float v1, float v2);
internal delegate void glUniform4f(int location, float v0, float v1, float v2, float v3);
internal delegate void glUniform1i(int location, int v0);
internal delegate void glUniform2i(int location, int v0, int v1);
internal delegate void glUniform3i(int location, int v0, int v1, int v2);
internal delegate void glUniform4i(int location, int v0, int v1, int v2, int v3);
internal delegate void glUniform1fv(int location, int count, float[] value);
internal delegate void glUniform2fv(int location, int count, float[] value);
internal delegate void glUniform3fv(int location, int count, float[] value);
internal delegate void glUniform4fv(int location, int count, float[] value);
internal delegate void glUniform1iv(int location, int count, int[] value);
internal delegate void glUniform2iv(int location, int count, int[] value);
internal delegate void glUniform3iv(int location, int count, int[] value);
internal delegate void glUniform4iv(int location, int count, int[] value);
internal delegate void glUniformMatrix2fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix3fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix4fv(int location, int count, bool transpose, float[] value);
internal delegate void glValidateProgram(uint program);
internal delegate void glVertexAttrib1d(uint index, double x);
internal delegate void glVertexAttrib1dv(uint index, double[] v);
internal delegate void glVertexAttrib1f(uint index, float x);
internal delegate void glVertexAttrib1fv(uint index, float[] v);
internal delegate void glVertexAttrib1s(uint index, short x);
internal delegate void glVertexAttrib1sv(uint index, short[] v);
internal delegate void glVertexAttrib2d(uint index, double x, double y);
internal delegate void glVertexAttrib2dv(uint index, double[] v);
internal delegate void glVertexAttrib2f(uint index, float x, float y);
internal delegate void glVertexAttrib2fv(uint index, float[] v);
internal delegate void glVertexAttrib2s(uint index, short x, short y);
internal delegate void glVertexAttrib2sv(uint index, short[] v);
internal delegate void glVertexAttrib3d(uint index, double x, double y, double z);
internal delegate void glVertexAttrib3dv(uint index, double[] v);
internal delegate void glVertexAttrib3f(uint index, float x, float y, float z);
internal delegate void glVertexAttrib3fv(uint index, float[] v);
internal delegate void glVertexAttrib3s(uint index, short x, short y, short z);
internal delegate void glVertexAttrib3sv(uint index, short[] v);
internal delegate void glVertexAttrib4Nbv(uint index, sbyte[] v);
internal delegate void glVertexAttrib4Niv(uint index, int[] v);
internal delegate void glVertexAttrib4Nsv(uint index, short[] v);
internal delegate void glVertexAttrib4Nub(uint index, byte x, byte y, byte z, byte w);
internal delegate void glVertexAttrib4Nubv(uint index, byte[] v);
internal delegate void glVertexAttrib4Nuiv(uint index, uint[] v);
internal delegate void glVertexAttrib4Nusv(uint index, ushort[] v);
internal delegate void glVertexAttrib4bv(uint index, sbyte[] v);
internal delegate void glVertexAttrib4d(uint index, double x, double y, double z, double w);
internal delegate void glVertexAttrib4dv(uint index, double[] v);
internal delegate void glVertexAttrib4f(uint index, float x, float y, float z, float w);
internal delegate void glVertexAttrib4fv(uint index, float[] v);
internal delegate void glVertexAttrib4iv(uint index, int[] v);
internal delegate void glVertexAttrib4s(uint index, short x, short y, short z, short w);
internal delegate void glVertexAttrib4sv(uint index, short[] v);
internal delegate void glVertexAttrib4ubv(uint index, byte[] v);
internal delegate void glVertexAttrib4uiv(uint index, uint[] v);
internal delegate void glVertexAttrib4usv(uint index, ushort[] v);
internal delegate void glVertexAttribPointer(uint index, int size, uint type, bool normalized, int stride, IntPtr pointer);
internal delegate void glUniformMatrix2x3fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix3x2fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix2x4fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix4x2fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix3x4fv(int location, int count, bool transpose, float[] value);
internal delegate void glUniformMatrix4x3fv(int location, int count, bool transpose, float[] value);
internal delegate void glColorMaski(uint index, bool r, bool g, bool b, bool a);
internal delegate void glGetBooleani_v(uint target, uint index, bool[] data);
internal delegate void glGetIntegeri_v(uint target, uint index, int[] data);
internal delegate void glEnablei(uint target, uint index);
internal delegate void glDisablei(uint target, uint index);
internal delegate bool glIsEnabledi(uint target, uint index);
internal delegate void glBeginTransformFeedback(uint primitiveMode);
internal delegate void glEndTransformFeedback();
internal delegate void glBindBufferRange(uint target, uint index, uint buffer, int offset, int size);
internal delegate void glBindBufferBase(uint target, uint index, uint buffer);
internal delegate void glTransformFeedbackVaryings(uint program, int count, IntPtr[] varyings, uint bufferMode);
internal delegate void glGetTransformFeedbackVarying(uint program, uint index, int bufSize, out int length,out int size, out uint type, byte[] name);
internal delegate void glClampColor(uint target, uint clamp);
internal delegate void glBeginConditionalRender(uint id, uint mode);
internal delegate void glEndConditionalRender();
internal delegate void glVertexAttribIPointer(uint index, int size, uint type, int stride, IntPtr pointer);
internal delegate void glGetVertexAttribIiv(uint index, uint pname, int[] Params);
internal delegate void glGetVertexAttribIuiv(uint index, uint pname, uint[] Params);
internal delegate void glVertexAttribI1i(uint index, int x);
internal delegate void glVertexAttribI2i(uint index, int x, int y);
internal delegate void glVertexAttribI3i(uint index, int x, int y, int z);
internal delegate void glVertexAttribI4i(uint index, int x, int y, int z, int w);
internal delegate void glVertexAttribI1ui(uint index, uint x);
internal delegate void glVertexAttribI2ui(uint index, uint x, uint y);
internal delegate void glVertexAttribI3ui(uint index, uint x, uint y, uint z);
internal delegate void glVertexAttribI4ui(uint index, uint x, uint y, uint z, uint w);
internal delegate void glVertexAttribI1iv(uint index, int[] v);
internal delegate void glVertexAttribI2iv(uint index, int[] v);
internal delegate void glVertexAttribI3iv(uint index, int[] v);
internal delegate void glVertexAttribI4iv(uint index, int[] v);
internal delegate void glVertexAttribI1uiv(uint index, uint[] v);
internal delegate void glVertexAttribI2uiv(uint index, uint[] v);
internal delegate void glVertexAttribI3uiv(uint index, uint[] v);
internal delegate void glVertexAttribI4uiv(uint index, uint[] v);
internal delegate void glVertexAttribI4bv(uint index, sbyte[] v);
internal delegate void glVertexAttribI4sv(uint index, short[] v);
internal delegate void glVertexAttribI4ubv(uint index, byte[] v);
internal delegate void glVertexAttribI4usv(uint index, ushort[] v);
internal delegate void glGetUniformuiv(uint program, int location, uint[] Params);
internal delegate void glBindFragDataLocation(uint program, uint color, byte[] name);
internal delegate int glGetFragDataLocation(uint program, byte[] name);
internal delegate void glUniform1ui(int location, uint v0);
internal delegate void glUniform2ui(int location, uint v0, uint v1);
internal delegate void glUniform3ui(int location, uint v0, uint v1, uint v2);
internal delegate void glUniform4ui(int location, uint v0, uint v1, uint v2, uint v3);
internal delegate void glUniform1uiv(int location, int count, uint[] value);
internal delegate void glUniform2uiv(int location, int count, uint[] value);
internal delegate void glUniform3uiv(int location, int count, uint[] value);
internal delegate void glUniform4uiv(int location, int count, uint[] value);
internal delegate void glTexParameterIiv(uint target, uint pname, int[] Params);
internal delegate void glTexParameterIuiv(uint target, uint pname, uint[] Params);
internal delegate void glGetTexParameterIiv(uint target, uint pname, int[] Params);
internal delegate void glGetTexParameterIuiv(uint target, uint pname, uint[] Params);
internal delegate void glClearBufferiv(uint buffer, int drawbuffer, int[] value);
internal delegate void glClearBufferuiv(uint buffer, int drawbuffer, uint[] value);
internal delegate void glClearBufferfv(uint buffer, int drawbuffer, float[] value);
internal delegate void glClearBufferfi(uint buffer, int drawbuffer, float depth, int stencil);
internal delegate IntPtr glGetStringi(uint name, uint index);
internal delegate bool glIsRenderbuffer(uint renderbuffer);
internal delegate void glBindRenderbuffer(uint target, uint renderbuffer);
internal delegate void glDeleteRenderbuffers(int n, uint[] renderbuffers);
internal delegate void glGenRenderbuffers(int n, uint[] renderbuffers);
internal delegate void glRenderbufferStorage(uint target, uint internalformat, int width, int height);
internal delegate void glGetRenderbufferParameteriv(uint target, uint pname, int[] Params);
internal delegate bool glIsFramebuffer(uint framebuffer);
internal delegate void glBindFramebuffer(uint target, uint framebuffer);
internal delegate void glDeleteFramebuffers(int n, uint[] framebuffers);
internal delegate void glGenFramebuffers(int n, uint[] framebuffers);
internal delegate uint glCheckFramebufferStatus(uint target);
internal delegate void glFramebufferTexture1D(uint target, uint attachment, uint textarget, uint texture, int level);
internal delegate void glFramebufferTexture2D(uint target, uint attachment, uint textarget, uint texture, int level);
internal delegate void glFramebufferTexture3D(uint target, uint attachment, uint textarget, uint texture, int level, int zoffset);
internal delegate void glFramebufferRenderbuffer(uint target, uint attachment, uint renderbuffertarget, uint renderbuffer);
internal delegate void glGetFramebufferAttachmentParameteriv(uint target, uint attachment, uint pname, int[] Params);
internal delegate void glGenerateMipmap(uint target);
internal delegate void glBlitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter);
internal delegate void glRenderbufferStorageMultisample(uint target, int samples, uint internalformat, int width, int height);
internal delegate void glFramebufferTextureLayer(uint target, uint attachment, uint texture, int level, int layer);
internal delegate void glMapBufferRange(uint target, int offset, int length, uint access);
internal delegate void glFlushMappedBufferRange(uint target, int offset, int length);
internal delegate void glBindVertexArray(uint array);
internal delegate void glDeleteVertexArrays(int n, uint[] arrays);
internal delegate void glGenVertexArrays(int n, uint[] arrays);
internal delegate bool glIsVertexArray(uint array);
internal delegate void glDrawArraysInstanced(uint mode, int first, int count, int instancecount);
internal delegate void glDrawElementsInstanced(uint mode, int count, uint type, IntPtr indices, int instancecount);
internal delegate void glTexBuffer(uint target, uint internalformat, uint buffer);
internal delegate void glPrimitiveRestartIndex(uint index);
internal delegate void glCopyBufferSubData(uint readTarget, uint writeTarget, int readOffset, int writeOffset, int size);
internal delegate void glGetUniformIndices(uint program, int uniformCount, IntPtr[] uniformNames, uint[] uniformIndices);
internal delegate void glGetActiveUniformsiv(uint program, int uniformCount, uint[] uniformIndices, uint pname, int[] Params);
internal delegate void glGetActiveUniformName(uint program, uint uniformIndex, int bufSize, out int length, byte[] uniformName);
internal delegate uint glGetUniformBlockIndex(uint program, byte[] uniformBlockName);
internal delegate void glGetActiveUniformBlockiv(uint program, uint uniformBlockIndex, uint pname, int[] Params);
internal delegate void glGetActiveUniformBlockName(uint program, uint uniformBlockIndex, int bufSize, out int length, byte[] uniformBlockName);
internal delegate void glUniformBlockBinding(uint program, uint uniformBlockIndex, uint uniformBlockBinding);
internal delegate void glDrawElementsBaseVertex(uint mode, int count, uint type, IntPtr indices, int basevertex);
internal delegate void glDrawRangeElementsBaseVertex(uint mode, uint start, uint end, int count, uint type, IntPtr indices, int basevertex);
internal delegate void glDrawElementsInstancedBaseVertex(uint mode, int count, uint type, IntPtr indices, int instancecount, int basevertex);
internal delegate void glMultiDrawElementsBaseVertex(uint mode, int[] count, uint type, IntPtr[] indices, int drawcount, int[] basevertex);
internal delegate void glProvokingVertex(uint mode);
internal delegate IntPtr glFenceSync(uint condition, uint flags);
internal delegate bool glIsSync(IntPtr sync);
internal delegate void glDeleteSync(IntPtr sync);
internal delegate uint glClientWaitSync(IntPtr sync, uint flags, UInt64 timeout);
internal delegate void glWaitSync(IntPtr sync, uint flags, UInt64 timeout);
internal delegate void glGetInteger64v(uint pname, Int64[] data);
internal delegate void glGetSynciv(IntPtr sync, uint pname, int bufSize, out int length, int[] values);
internal delegate void glGetInteger64i_v(uint target, uint index, Int64[] data);
internal delegate void glGetBufferParameteri64v(uint target, uint pname, Int64[] Params);
internal delegate void glFramebufferTexture(uint target, uint attachment, uint texture, int level);
internal delegate void glTexImage2DMultisample(uint target, int samples, uint internalformat, int width, int height, bool fixedsamplelocations);
internal delegate void glTexImage3DMultisample(uint target, int samples, uint internalformat, int width, int height, int depth, bool fixedsamplelocations);
internal delegate void glGetMultisamplefv(uint pname, uint index, float[] val);
internal delegate void glSampleMaski(uint maskNumber, uint mask);
internal delegate void glBindFragDataLocationIndexed(uint program, uint colorNumber, uint index, byte[] name);
internal delegate int glGetFragDataIndex(uint program, byte[] name);
internal delegate void glGenSamplers(int count, uint[] samplers);
internal delegate void glDeleteSamplers(int count, uint[] samplers);
internal delegate bool glIsSampler(uint sampler);
internal delegate void glBindSampler(uint unit, uint sampler);
internal delegate void glSamplerParameteri(uint sampler, uint pname, int Param);
internal delegate void glSamplerParameteriv(uint sampler, uint pname, int[] Param);
internal delegate void glSamplerParameterf(uint sampler, uint pname, float Param);
internal delegate void glSamplerParameterfv(uint sampler, uint pname, float[] Param);
internal delegate void glSamplerParameterIiv(uint sampler, uint pname, int[] Param);
internal delegate void glSamplerParameterIuiv(uint sampler, uint pname, uint[] Param);
internal delegate void glGetSamplerParameteriv(uint sampler, uint pname, int[] Params);
internal delegate void glGetSamplerParameterIiv(uint sampler, uint pname, int[] Params);
internal delegate void glGetSamplerParameterfv(uint sampler, uint pname, float[] Params);
internal delegate void glGetSamplerParameterIuiv(uint sampler, uint pname, uint[] Params);
internal delegate void glQueryCounter(uint id, uint target);
internal delegate void glGetQueryObjecti64v(uint id, uint pname, Int64[] Params);
internal delegate void glGetQueryObjectui64v(uint id, uint pname, UInt64[] Params);
internal delegate void glVertexAttribDivisor(uint index, uint divisor);
internal delegate void glVertexAttribP1ui(uint index, uint type, bool normalized, uint value);
internal delegate void glVertexAttribP1uiv(uint index, uint type, bool normalized, uint[] value);
internal delegate void glVertexAttribP2ui(uint index, uint type, bool normalized, uint value);
internal delegate void glVertexAttribP2uiv(uint index, uint type, bool normalized, uint[] value);
internal delegate void glVertexAttribP3ui(uint index, uint type, bool normalized, uint value);
internal delegate void glVertexAttribP3uiv(uint index, uint type, bool normalized, uint[] value);
internal delegate void glVertexAttribP4ui(uint index, uint type, bool normalized, uint value);
internal delegate void glVertexAttribP4uiv(uint index, uint type, bool normalized, uint[] value);
internal delegate void glMinSampleShading(float value);
internal delegate void glBlendEquationi(uint buf, uint mode);
internal delegate void glBlendEquationSeparatei(uint buf, uint modeRGB, uint modeAlpha);
internal delegate void glBlendFunci(uint buf, uint src, uint dst);
internal delegate void glBlendFuncSeparatei(uint buf, uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha);
internal delegate void glDrawArraysIndirect(uint mode, IntPtr indirect);
internal delegate void glDrawElementsIndirect(uint mode, uint type, IntPtr indirect);
internal delegate void glUniform1d(int location, double x);
internal delegate void glUniform2d(int location, double x, double y);
internal delegate void glUniform3d(int location, double x, double y, double z);
internal delegate void glUniform4d(int location, double x, double y, double z, double w);
internal delegate void glUniform1dv(int location, int count, double[] value);
internal delegate void glUniform2dv(int location, int count, double[] value);
internal delegate void glUniform3dv(int location, int count, double[] value);
internal delegate void glUniform4dv(int location, int count, double[] value);
internal delegate void glUniformMatrix2dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix3dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix4dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix2x3dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix2x4dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix3x2dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix3x4dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix4x2dv(int location, int count, bool transpose, double[] value);
internal delegate void glUniformMatrix4x3dv(int location, int count, bool transpose, double[] value);
internal delegate void glGetUniformdv(uint program, int location, double[] Params);
internal delegate int glGetSubroutineUniformLocation(uint program, uint shadertype, byte[] name);
internal delegate int glGetSubroutineIndex(uint program, uint shadertype, byte[] name);
internal delegate void glGetActiveSubroutineUniformiv(uint program, uint shadertype, uint index, uint pname, int[] values);
internal delegate void glGetActiveSubroutineUniformName(uint program, uint shadertype, uint index, int bufsize, out int length, byte[] name);
internal delegate void glGetActiveSubroutineName(uint program, uint shadertype, uint index, int bufsize, out int length, byte[] name);
internal delegate void glUniformSubroutinesuiv(uint shadertype, int count, uint[] indices);
internal delegate void glGetUniformSubroutineuiv(uint shadertype, int location, uint[] Params);
internal delegate void glGetProgramStageiv(uint program, uint shadertype, uint pname, int[] values);
internal delegate void glPatchParameteri(uint pname, int value);
internal delegate void glPatchParameterfv(uint pname, float[] values);
internal delegate void glBindTransformFeedback(uint target, uint id);
internal delegate void glDeleteTransformFeedbacks(int n, uint[] ids);
internal delegate void glGenTransformFeedbacks(int n, uint[] ids);
internal delegate bool glIsTransformFeedback(uint id);
internal delegate void glPauseTransformFeedback();
internal delegate void glResumeTransformFeedback();
internal delegate void glDrawTransformFeedback(uint mode, uint id);
internal delegate void glDrawTransformFeedbackStream(uint mode, uint id, uint stream);
internal delegate void glBeginQueryIndexed(uint target, uint index, uint id);
internal delegate void glEndQueryIndexed(uint target, uint index);
internal delegate void glGetQueryIndexediv(uint target, uint index, uint pname, int[] Params);
internal delegate void glReleaseShaderCompiler();
internal delegate void glShaderBinary(int count, uint[] shaders, uint binaryformat, IntPtr binary, int length);
internal delegate void glGetShaderPrecisionFormat(uint shadertype, uint precisiontype, int[] range, out int precision);
internal delegate void glDepthRangef(float n, float f);
internal delegate void glClearDepthf(float d);
internal delegate void glGetProgramBinary(uint program, int bufSize, out int length, out uint binaryFormat, IntPtr binary);
internal delegate void glProgramBinary(uint program, uint binaryFormat, IntPtr binary, int length);
internal delegate void glProgramParameteri(uint program, uint pname, int value);
internal delegate void glUseProgramStages(uint pipeline, uint stages, uint program);
internal delegate void glActiveShaderProgram(uint pipeline, uint program);
internal delegate uint glCreateShaderProgramv(uint type, int count, IntPtr[] strings);
internal delegate void glBindProgramPipeline(uint pipeline);
internal delegate void glDeleteProgramPipelines(int n, uint[] pipelines);
internal delegate void glGenProgramPipelines(int n, uint[] pipelines);
internal delegate bool glIsProgramPipeline(uint pipeline);
internal delegate void glGetProgramPipelineiv(uint pipeline, uint pname, int[] Params);
internal delegate void glProgramUniform1i(uint program, int location, int v0);
internal delegate void glProgramUniform1iv(uint program, int location, int count, int[] value);
internal delegate void glProgramUniform1f(uint program, int location, float v0);
internal delegate void glProgramUniform1fv(uint program, int location, int count, float[] value);
internal delegate void glProgramUniform1d(uint program, int location, double v0);
internal delegate void glProgramUniform1dv(uint program, int location, int count, double[] value);
internal delegate void glProgramUniform1ui(uint program, int location, uint v0);
internal delegate void glProgramUniform1uiv(uint program, int location, int count, uint[] value);
internal delegate void glProgramUniform2i(uint program, int location, int v0, int v1);
internal delegate void glProgramUniform2iv(uint program, int location, int count, int[] value);
internal delegate void glProgramUniform2f(uint program, int location, float v0, float v1);
internal delegate void glProgramUniform2fv(uint program, int location, int count, float[] value);
internal delegate void glProgramUniform2d(uint program, int location, double v0, double v1);
internal delegate void glProgramUniform2dv(uint program, int location, int count, double[] value);
internal delegate void glProgramUniform2ui(uint program, int location, uint v0, uint v1);
internal delegate void glProgramUniform2uiv(uint program, int location, int count, uint[] value);
internal delegate void glProgramUniform3i(uint program, int location, int v0, int v1, int v2);
internal delegate void glProgramUniform3iv(uint program, int location, int count, int[] value);
internal delegate void glProgramUniform3f(uint program, int location, float v0, float v1, float v2);
internal delegate void glProgramUniform3fv(uint program, int location, int count, float[] value);
internal delegate void glProgramUniform3d(uint program, int location, double v0, double v1, double v2);
internal delegate void glProgramUniform3dv(uint program, int location, int count, double[] value);
internal delegate void glProgramUniform3ui(uint program, int location, uint v0, uint v1, uint v2);
internal delegate void glProgramUniform3uiv(uint program, int location, int count, uint[] value);
internal delegate void glProgramUniform4i(uint program, int location, int v0, int v1, int v2, int v3);
internal delegate void glProgramUniform4iv(uint program, int location, int count, int[] value);
internal delegate void glProgramUniform4f(uint program, int location, float v0, float v1, float v2, float v3);
internal delegate void glProgramUniform4fv(uint program, int location, int count, float[] value);
internal delegate void glProgramUniform4d(uint program, int location, double v0, double v1, double v2, double v3);
internal delegate void glProgramUniform4dv(uint program, int location, int count, double[] value);
internal delegate void glProgramUniform4ui(uint program, int location, uint v0, uint v1, uint v2, uint v3);
internal delegate void glProgramUniform4uiv(uint program, int location, int count, uint[] value);
internal delegate void glProgramUniformMatrix2fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix3fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix4fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix2dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix3dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix4dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix2x3fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix3x2fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix2x4fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix4x2fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix3x4fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix4x3fv(uint program, int location, int count, bool transpose, float[] value);
internal delegate void glProgramUniformMatrix2x3dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix3x2dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix2x4dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix4x2dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix3x4dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glProgramUniformMatrix4x3dv(uint program, int location, int count, bool transpose, double[] value);
internal delegate void glValidateProgramPipeline(uint pipeline);
internal delegate void glGetProgramPipelineInfoLog(uint pipeline, int bufSize, out int length, byte[] infoLog);
internal delegate void glVertexAttribL1d(uint index, double x);
internal delegate void glVertexAttribL2d(uint index, double x, double y);
internal delegate void glVertexAttribL3d(uint index, double x, double y, double z);
internal delegate void glVertexAttribL4d(uint index, double x, double y, double z, double w);
internal delegate void glVertexAttribL1dv(uint index, double[] v);
internal delegate void glVertexAttribL2dv(uint index, double[] v);
internal delegate void glVertexAttribL3dv(uint index, double[] v);
internal delegate void glVertexAttribL4dv(uint index, double[] v);
internal delegate void glVertexAttribLPointer(uint index, int size, uint type, int stride, IntPtr pointer);
internal delegate void glGetVertexAttribLdv(uint index, uint pname, double[] Params);
internal delegate void glViewportArrayv(uint first, int count, float[] v);
internal delegate void glViewportIndexedf(uint index, float x, float y, float w, float h);
internal delegate void glViewportIndexedfv(uint index, float[] v);
internal delegate void glScissorArrayv(uint first, int count, int[] v);
internal delegate void glScissorIndexed(uint index, int left, int bottom, int width, int height);
internal delegate void glScissorIndexedv(uint index, int[] v);
internal delegate void glDepthRangeArrayv(uint first, int count, double[] v);
internal delegate void glDepthRangeIndexed(uint index, double n, double f);
internal delegate void glGetFloati_v(uint target, uint index, float[] data);
internal delegate void glGetDoublei_v(uint target, uint index, double[] data);
internal delegate void glDrawArraysInstancedBaseInstance(uint mode, int first, int count, int instancecount, uint baseinstance);
internal delegate void glDrawElementsInstancedBaseInstance(uint mode, int count, uint type, IntPtr indices, int instancecount, uint baseinstance);
internal delegate void glDrawElementsInstancedBaseVertexBaseInstance(uint mode, int count, uint type, IntPtr indices, int instancecount, int basevertex, uint baseinstance);
internal delegate void glGetInternalformativ(uint target, uint internalformat, uint pname, int bufSize, int[] Params);
internal delegate void glGetActiveAtomicCounterBufferiv(uint program, uint bufferIndex, uint pname, int[] Params);
internal delegate void glBindImageTexture(uint unit, uint texture, int level, bool layered, int layer, uint access, uint format);
internal delegate void glMemoryBarrier(uint barriers);
internal delegate void glTexStorage1D(uint target, int levels, uint internalformat, int width);
internal delegate void glTexStorage2D(uint target, int levels, uint internalformat, int width, int height);
internal delegate void glTexStorage3D(uint target, int levels, uint internalformat, int width, int height, int depth);
internal delegate void glDrawTransformFeedbackInstanced(uint mode, uint id, int instancecount);
internal delegate void glDrawTransformFeedbackStreamInstanced(uint mode, uint id, uint stream, int instancecount);
internal delegate void glClearBufferData(uint target, uint internalformat, uint format, uint type, IntPtr data);
internal delegate void glClearBufferSubData(uint target, uint internalformat, int offset, int size, uint format, uint type, IntPtr data);
internal delegate void glDispatchCompute(uint num_groups_x, uint num_groups_y, uint num_groups_z);
internal delegate void glDispatchComputeIndirect(int indirect);
internal delegate void glCopyImageSubData(uint srcName, uint srcTarget, int srcLevel, int srcX, int srcY, int srcZ, uint dstName, uint dstTarget, int dstLevel, int dstX, int dstY, int dstZ, int srcWidth, int srcHeight, int srcDepth);
internal delegate void glFramebufferParameteri(uint target, uint pname, int Param);
internal delegate void glGetFramebufferParameteriv(uint target, uint pname, int[] Params);
internal delegate void glGetInternalformati64v(uint target, uint internalformat, uint pname, int bufSize, Int64[] Params);
internal delegate void glInvalidateTexSubImage(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth);
internal delegate void glInvalidateTexImage(uint texture, int level);
internal delegate void glInvalidateBufferSubData(uint buffer, int offset, int length);
internal delegate void glInvalidateBufferData(uint buffer);
internal delegate void glInvalidateFramebuffer(uint target, int numAttachments, uint[] attachments);
internal delegate void glInvalidateSubFramebuffer(uint target, int numAttachments, uint[] attachments, int x, int y, int width, int height);
internal delegate void glMultiDrawArraysIndirect(uint mode, IntPtr indirect, int drawcount, int stride);
internal delegate void glMultiDrawElementsIndirect(uint mode, uint type, IntPtr indirect, int drawcount, int stride);
internal delegate void glGetProgramInterfaceiv(uint program, uint programInterface, uint pname, int[] Params);
internal delegate uint glGetProgramResourceIndex(uint program, uint programInterface, byte[] name);
internal delegate void glGetProgramResourceName(uint program, uint programInterface, uint index, int bufSize, out int length, byte[] name);
internal delegate void glGetProgramResourceiv(uint program, uint programInterface, uint index, int propCount, uint[] props, int bufSize, out int length, int[] Params);
internal delegate int glGetProgramResourceLocation(uint program, uint programInterface, byte[] name);
internal delegate int glGetProgramResourceLocationIndex(uint program, uint programInterface, byte[] name);
internal delegate void glShaderStorageBlockBinding(uint program, uint storageBlockIndex, uint storageBlockBinding);
internal delegate void glTexBufferRange(uint target, uint internalformat, uint buffer, int offset, int size);
internal delegate void glTexStorage2DMultisample(uint target, int samples, uint internalformat, int width, int height, bool fixedsamplelocations);
internal delegate void glTexStorage3DMultisample(uint target, int samples, uint internalformat, int width, int height, int depth, bool fixedsamplelocations);
internal delegate void glTextureView(uint texture, uint target, uint origtexture, uint internalformat, uint minlevel, uint numlevels, uint minlayer, uint numlayers);
internal delegate void glBindVertexBuffer(uint bindingindex, uint buffer, int offset, int stride);
internal delegate void glVertexAttribFormat(uint attribindex, int size, uint type, bool normalized, uint relativeoffset);
internal delegate void glVertexAttribIFormat(uint attribindex, int size, uint type, uint relativeoffset);
internal delegate void glVertexAttribLFormat(uint attribindex, int size, uint type, uint relativeoffset);
internal delegate void glVertexAttribBinding(uint attribindex, uint bindingindex);
internal delegate void glVertexBindingDivisor(uint bindingindex, uint divisor);
internal delegate void glDebugMessageControl(uint source, uint type, uint severity, int count, uint[] ids, bool enabled);
internal delegate void glDebugMessageInsert(uint source, uint type, uint id, uint severity, int length, byte[] buf);
internal delegate void glDebugMessageCallback(IntPtr callback, IntPtr userParam);
internal delegate uint glGetDebugMessageLog(uint count, int bufSize, uint[] sources, uint[] types, uint[] ids, uint[] severities, int[] lengths, byte[] messageLog);
internal delegate void glPushDebugGroup(uint source, uint id, int length, byte[] message);
internal delegate void glPopDebugGroup();
internal delegate void glObjectLabel(uint identifier, uint name, int length, byte[] label);
internal delegate void glGetObjectLabel(uint identifier, uint name, int bufSize, out int length, byte[] label);
internal delegate void glObjectPtrLabel(IntPtr ptr, int length, byte[] label);
internal delegate void glGetObjectPtrLabel(IntPtr ptr, int bufSize, int[] length, byte[] label);
internal delegate void glBufferStorage(uint target, int size, IntPtr data, uint flags);
internal delegate void glClearTexImage(uint texture, int level, uint format, uint type, IntPtr data);
internal delegate void glClearTexSubImage(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, IntPtr data);
internal delegate void glBindBuffersBase(uint target, uint first, int count, uint[] buffers);
internal delegate void glBindBuffersRange(uint target, uint first, int count, uint[] buffers, int[] offsets, int[] sizes);
internal delegate void glBindTextures(uint first, int count, uint[] textures);
internal delegate void glBindSamplers(uint first, int count, uint[] samplers);
internal delegate void glBindImageTextures(uint first, int count, uint[] textures);
internal delegate void glBindVertexBuffers(uint first, int count, uint[] buffers, int offsets, int[] strides);
internal delegate void glClipControl(uint origin, uint depth);
internal delegate void glCreateTransformFeedbacks(int n, uint[] ids);
internal delegate void glTransformFeedbackBufferBase(uint xfb, uint index, uint buffer);
internal delegate void glTransformFeedbackBufferRange(uint xfb, uint index, uint buffer, int offset, int size);
internal delegate void glGetTransformFeedbackiv(uint xfb, uint pname, int[] Param);
internal delegate void glGetTransformFeedbacki_v(uint xfb, uint pname, uint index, int[] Param);
internal delegate void glGetTransformFeedbacki64_v(uint xfb, uint pname, uint index, Int64[] Param);
internal delegate void glCreateBuffers(int n, uint[] buffers);
internal delegate void glNamedBufferStorage(uint buffer, int size, IntPtr data, uint flags);
internal delegate void glNamedBufferData(uint buffer, int size, IntPtr data, uint usage);
internal delegate void glNamedBufferSubData(uint buffer, int offset, int size, IntPtr data);
internal delegate void glCopyNamedBufferSubData(uint readBuffer, uint writeBuffer, int readOffset, int writeOffset, int size);
internal delegate void glClearNamedBufferData(uint buffer, uint internalformat, uint format, uint type, IntPtr data);
internal delegate void glClearNamedBufferSubData(uint buffer, uint internalformat, int offset, int size, uint format, uint type, IntPtr data);
internal delegate void glMapNamedBuffer(uint buffer, uint access);
internal delegate void glMapNamedBufferRange(uint buffer, int offset, int length, uint access);
internal delegate bool glUnmapNamedBuffer(uint buffer);
internal delegate void glFlushMappedNamedBufferRange(uint buffer, int offset, int length);
internal delegate void glGetNamedBufferParameteriv(uint buffer, uint pname, int[] Params);
internal delegate void glGetNamedBufferParameteri64v(uint buffer, uint pname, Int64[] Params);
internal delegate void glGetNamedBufferPointerv(uint buffer, uint pname, IntPtr[] Params);
internal delegate void glGetNamedBufferSubData(uint buffer, int offset, int size, IntPtr data);
internal delegate void glCreateFramebuffers(int n, uint[] framebuffers);
internal delegate void glNamedFramebufferRenderbuffer(uint framebuffer, uint attachment, uint renderbuffertarget, uint renderbuffer);
internal delegate void glNamedFramebufferParameteri(uint framebuffer, uint pname, int Param);
internal delegate void glNamedFramebufferTexture(uint framebuffer, uint attachment, uint texture, int level);
internal delegate void glNamedFramebufferTextureLayer(uint framebuffer, uint attachment, uint texture, int level, int layer);
internal delegate void glNamedFramebufferDrawBuffer(uint framebuffer, uint buf);
internal delegate void glNamedFramebufferDrawBuffers(uint framebuffer, int n, uint[] bufs);
internal delegate void glNamedFramebufferReadBuffer(uint framebuffer, uint src);
internal delegate void glInvalidateNamedFramebufferData(uint framebuffer, int numAttachments, uint[] attachments);
internal delegate void glInvalidateNamedFramebufferSubData(uint framebuffer, int numAttachments, uint[] attachments, int x, int y, int width, int height);
internal delegate void glClearNamedFramebufferiv(uint framebuffer, uint buffer, int drawbuffer, int[] value);
internal delegate void glClearNamedFramebufferuiv(uint framebuffer, uint buffer, int drawbuffer, uint[] value);
internal delegate void glClearNamedFramebufferfv(uint framebuffer, uint buffer, int drawbuffer, float[] value);
internal delegate void glClearNamedFramebufferfi(uint framebuffer, uint buffer, int drawbuffer, float depth, int stencil);
internal delegate void glBlitNamedFramebuffer(uint readFramebuffer, uint drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter);
internal delegate uint glCheckNamedFramebufferStatus(uint framebuffer, uint target);
internal delegate void glGetNamedFramebufferParameteriv(uint framebuffer, uint pname, int[] Param);
internal delegate void glGetNamedFramebufferAttachmentParameteriv(uint framebuffer, uint attachment, uint pname, int[] Params);
internal delegate void glCreateRenderbuffers(int n, uint[] renderbuffers);
internal delegate void glNamedRenderbufferStorage(uint renderbuffer, uint internalformat, int width, int height);
internal delegate void glNamedRenderbufferStorageMultisample(uint renderbuffer, int samples, uint internalformat, int width, int height);
internal delegate void glGetNamedRenderbufferParameteriv(uint renderbuffer, uint pname, int[] Params);
internal delegate void glCreateTextures(uint target, int n, uint[] textures);
internal delegate void glTextureBuffer(uint texture, uint internalformat, uint buffer);
internal delegate void glTextureBufferRange(uint texture, uint internalformat, uint buffer, int offset, int size);
internal delegate void glTextureStorage1D(uint texture, int levels, uint internalformat, int width);
internal delegate void glTextureStorage2D(uint texture, int levels, uint internalformat, int width, int height);
internal delegate void glTextureStorage3D(uint texture, int levels, uint internalformat, int width, int height, int depth);
internal delegate void glTextureStorage2DMultisample(uint texture, int samples, uint internalformat, int width, int height, bool fixedsamplelocations);
internal delegate void glTextureStorage3DMultisample(uint texture, int samples, uint internalformat, int width, int height, int depth, bool fixedsamplelocations);
internal delegate void glTextureSubImage1D(uint texture, int level, int xoffset, int width, uint format, uint type, IntPtr pixels);
internal delegate void glTextureSubImage2D(uint texture, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, IntPtr pixels);
internal delegate void glTextureSubImage3D(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, IntPtr pixels);
internal delegate void glCompressedTextureSubImage1D(uint texture, int level, int xoffset, int width, uint format, int imageSize, IntPtr data);
internal delegate void glCompressedTextureSubImage2D(uint texture, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, IntPtr data);
internal delegate void glCompressedTextureSubImage3D(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, IntPtr data);
internal delegate void glCopyTextureSubImage1D(uint texture, int level, int xoffset, int x, int y, int width);
internal delegate void glCopyTextureSubImage2D(uint texture, int level, int xoffset, int yoffset, int x, int y, int width, int height);
internal delegate void glCopyTextureSubImage3D(uint texture, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
internal delegate void glTextureParameterf(uint texture, uint pname, float Param);
internal delegate void glTextureParameterfv(uint texture, uint pname, float[] Param);
internal delegate void glTextureParameteri(uint texture, uint pname, int Param);
internal delegate void glTextureParameterIiv(uint texture, uint pname, int[] Params);
internal delegate void glTextureParameterIuiv(uint texture, uint pname, uint[] Params);
internal delegate void glTextureParameteriv(uint texture, uint pname, int[] Param);
internal delegate void glGenerateTextureMipmap(uint texture);
internal delegate void glBindTextureUnit(uint unit, uint texture);
internal delegate void glGetTextureImage(uint texture, int level, uint format, uint type, int bufSize, IntPtr pixels);
internal delegate void glGetCompressedTextureImage(uint texture, int level, int bufSize, IntPtr pixels);
internal delegate void glGetTextureLevelParameterfv(uint texture, int level, uint pname, float[] Params);
internal delegate void glGetTextureLevelParameteriv(uint texture, int level, uint pname, int[] Params);
internal delegate void glGetTextureParameterfv(uint texture, uint pname, float[] Params);
internal delegate void glGetTextureParameterIiv(uint texture, uint pname, int[] Params);
internal delegate void glGetTextureParameterIuiv(uint texture, uint pname, uint[] Params);
internal delegate void glGetTextureParameteriv(uint texture, uint pname, int[] Params);
internal delegate void glCreateVertexArrays(int n, uint[] arrays);
internal delegate void glDisableVertexArrayAttrib(uint vaobj, uint index);
internal delegate void glEnableVertexArrayAttrib(uint vaobj, uint index);
internal delegate void glVertexArrayElementBuffer(uint vaobj, uint buffer);
internal delegate void glVertexArrayVertexBuffer(uint vaobj, uint bindingindex, uint buffer, int offset, int stride);
internal delegate void glVertexArrayVertexBuffers(uint vaobj, uint first, int count, uint[] buffers, int[] offsets, int[] strides);
internal delegate void glVertexArrayAttribBinding(uint vaobj, uint attribindex, uint bindingindex);
internal delegate void glVertexArrayAttribFormat(uint vaobj, uint attribindex, int size, uint type, bool normalized, uint relativeoffset);
internal delegate void glVertexArrayAttribIFormat(uint vaobj, uint attribindex, int size, uint type, uint relativeoffset);
internal delegate void glVertexArrayAttribLFormat(uint vaobj, uint attribindex, int size, uint type, uint relativeoffset);
internal delegate void glVertexArrayBindingDivisor(uint vaobj, uint bindingindex, uint divisor);
internal delegate void glGetVertexArrayiv(uint vaobj, uint pname, int[] Param);
internal delegate void glGetVertexArrayIndexediv(uint vaobj, uint index, uint pname, int[] Param);
internal delegate void glGetVertexArrayIndexed64iv(uint vaobj, uint index, uint pname, Int64[] Param);
internal delegate void glCreateSamplers(int n, uint[] samplers);
internal delegate void glCreateProgramPipelines(int n, uint[] pipelines);
internal delegate void glCreateQueries(uint target, int n, uint[] ids);
internal delegate void glGetQueryBufferObjecti64v(uint id, uint buffer, uint pname, int offset);
internal delegate void glGetQueryBufferObjectiv(uint id, uint buffer, uint pname, int offset);
internal delegate void glGetQueryBufferObjectui64v(uint id, uint buffer, uint pname, int offset);
internal delegate void glGetQueryBufferObjectuiv(uint id, uint buffer, uint pname, int offset);
internal delegate void glMemoryBarrierByRegion(uint barriers);
internal delegate void glGetTextureSubImage(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, int bufSize, IntPtr pixels);
internal delegate void glGetCompressedTextureSubImage(uint texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int bufSize, IntPtr pixels);
internal delegate uint glGetGraphicsResetStatus();
internal delegate void glGetnCompressedTexImage(uint target, int lod, int bufSize, IntPtr pixels);
internal delegate void glGetnTexImage(uint target, int level, uint format, uint type, int bufSize, IntPtr pixels);
internal delegate void glGetnUniformdv(uint program, int location, int bufSize, double[] Params);
internal delegate void glGetnUniformfv(uint program, int location, int bufSize, float[] Params);
internal delegate void glGetnUniformiv(uint program, int location, int bufSize, int[] Params);
internal delegate void glGetnUniformuiv(uint program, int location, int bufSize, uint[] Params);
internal delegate void glReadnPixels(int x, int y, int width, int height, uint format, uint type, int bufSize, IntPtr data);
internal delegate void glTextureBarrier();
internal delegate void glSpecializeShader(uint shader, byte[] pEntryPoint, uint numSpecializationConstants, uint[] pConstantIndex, uint[] pConstantValue);
internal delegate void glMultiDrawArraysIndirectCount(uint mode, IntPtr indirect, int drawcount, int maxdrawcount, int stride);
internal delegate void glMultiDrawElementsIndirectCount(uint mode, uint type, IntPtr indirect, int drawcount, int maxdrawcount, int stride);
internal delegate void glPolygonOffsetClamp(float factor, float units, float clamp);
}
}
@@ -0,0 +1,604 @@
namespace StgSharp.Graphics
{
public partial class gl
{
internal static string[] extension_function_names = new string[]
{
"glDrawRangeElements",
"glTexImage3D",
"glTexSubImage3D",
"glCopyTexSubImage3D",
"glActiveTexture",
"glSampleCoverage",
"glCompressedTexImage3D",
"glCompressedTexImage2D",
"glCompressedTexImage1D",
"glCompressedTexSubImage3D",
"glCompressedTexSubImage2D",
"glCompressedTexSubImage1D",
"glGetCompressedTexImage",
"glBlendFuncSeparate",
"glMultiDrawArrays",
"glMultiDrawElements",
"glPointParameterf",
"glPointParameterfv",
"glPointParameteri",
"glPointParameteriv",
"glBlendColor",
"glBlendEquation",
"glGenQueries",
"glDeleteQueries",
"glIsQuery",
"glBeginQuery",
"glEndQuery",
"glGetQueryiv",
"glGetQueryObjectiv",
"glGetQueryObjectuiv",
"glBindBuffer",
"glDeleteBuffers",
"glGenBuffers",
"glIsBuffer",
"glBufferData",
"glBufferSubData",
"glGetBufferSubData",
"glMapBuffer",
"glUnmapBuffer",
"glGetBufferParameteriv",
"glGetBufferPointerv",
"glBlendEquationSeparate",
"glDrawBuffers",
"glStencilOpSeparate",
"glStencilFuncSeparate",
"glStencilMaskSeparate",
"glAttachShader",
"glBindAttribLocation",
"glCompileShader",
"glCreateProgram",
"glCreateShader",
"glDeleteProgram",
"glDeleteShader",
"glDetachShader",
"glDisableVertexAttribArray",
"glEnableVertexAttribArray",
"glGetActiveAttrib",
"glGetActiveUniform",
"glGetAttachedShaders",
"glGetAttribLocation",
"glGetProgramiv",
"glGetProgramInfoLog",
"glGetShaderiv",
"glGetShaderInfoLog",
"glGetShaderSource",
"glGetUniformLocation",
"glGetUniformfv",
"glGetUniformiv",
"glGetVertexAttribdv",
"glGetVertexAttribfv",
"glGetVertexAttribiv",
"glGetVertexAttribPointerv",
"glIsProgram",
"glIsShader",
"glLinkProgram",
"glShaderSource",
"glUseProgram",
"glUniform1f",
"glUniform2f",
"glUniform3f",
"glUniform4f",
"glUniform1i",
"glUniform2i",
"glUniform3i",
"glUniform4i",
"glUniform1fv",
"glUniform2fv",
"glUniform3fv",
"glUniform4fv",
"glUniform1iv",
"glUniform2iv",
"glUniform3iv",
"glUniform4iv",
"glUniformMatrix2fv",
"glUniformMatrix3fv",
"glUniformMatrix4fv",
"glValidateProgram",
"glVertexAttrib1d",
"glVertexAttrib1dv",
"glVertexAttrib1f",
"glVertexAttrib1fv",
"glVertexAttrib1s",
"glVertexAttrib1sv",
"glVertexAttrib2d",
"glVertexAttrib2dv",
"glVertexAttrib2f",
"glVertexAttrib2fv",
"glVertexAttrib2s",
"glVertexAttrib2sv",
"glVertexAttrib3d",
"glVertexAttrib3dv",
"glVertexAttrib3f",
"glVertexAttrib3fv",
"glVertexAttrib3s",
"glVertexAttrib3sv",
"glVertexAttrib4Nbv",
"glVertexAttrib4Niv",
"glVertexAttrib4Nsv",
"glVertexAttrib4Nub",
"glVertexAttrib4Nubv",
"glVertexAttrib4Nuiv",
"glVertexAttrib4Nusv",
"glVertexAttrib4bv",
"glVertexAttrib4d",
"glVertexAttrib4dv",
"glVertexAttrib4f",
"glVertexAttrib4fv",
"glVertexAttrib4iv",
"glVertexAttrib4s",
"glVertexAttrib4sv",
"glVertexAttrib4ubv",
"glVertexAttrib4uiv",
"glVertexAttrib4usv",
"glVertexAttribPointer",
"glUniformMatrix2x3fv",
"glUniformMatrix3x2fv",
"glUniformMatrix2x4fv",
"glUniformMatrix4x2fv",
"glUniformMatrix3x4fv",
"glUniformMatrix4x3fv",
"glColorMaski",
"glGetBooleani_v",
"glGetIntegeri_v",
"glEnablei",
"glDisablei",
"glIsEnabledi",
"glBeginTransformFeedback",
"glEndTransformFeedback",
"glBindBufferRange",
"glBindBufferBase",
"glTransformFeedbackVaryings",
"glGetTransformFeedbackVarying",
"glClampColor",
"glBeginConditionalRender",
"glEndConditionalRender",
"glVertexAttribIPointer",
"glGetVertexAttribIiv",
"glGetVertexAttribIuiv",
"glVertexAttribI1i",
"glVertexAttribI2i",
"glVertexAttribI3i",
"glVertexAttribI4i",
"glVertexAttribI1ui",
"glVertexAttribI2ui",
"glVertexAttribI3ui",
"glVertexAttribI4ui",
"glVertexAttribI1iv",
"glVertexAttribI2iv",
"glVertexAttribI3iv",
"glVertexAttribI4iv",
"glVertexAttribI1uiv",
"glVertexAttribI2uiv",
"glVertexAttribI3uiv",
"glVertexAttribI4uiv",
"glVertexAttribI4bv",
"glVertexAttribI4sv",
"glVertexAttribI4ubv",
"glVertexAttribI4usv",
"glGetUniformuiv",
"glBindFragDataLocation",
"glGetFragDataLocation",
"glUniform1ui",
"glUniform2ui",
"glUniform3ui",
"glUniform4ui",
"glUniform1uiv",
"glUniform2uiv",
"glUniform3uiv",
"glUniform4uiv",
"glTexParameterIiv",
"glTexParameterIuiv",
"glGetTexParameterIiv",
"glGetTexParameterIuiv",
"glClearBufferiv",
"glClearBufferuiv",
"glClearBufferfv",
"glClearBufferfi",
"glGetStringi",
"glIsRenderbuffer",
"glBindRenderbuffer",
"glDeleteRenderbuffers",
"glGenRenderbuffers",
"glRenderbufferStorage",
"glGetRenderbufferParameteriv",
"glIsFramebuffer",
"glBindFramebuffer",
"glDeleteFramebuffers",
"glGenFramebuffers",
"glCheckFramebufferStatus",
"glFramebufferTexture1D",
"glFramebufferTexture2D",
"glFramebufferTexture3D",
"glFramebufferRenderbuffer",
"glGetFramebufferAttachmentParameteriv",
"glGenerateMipmap",
"glBlitFramebuffer",
"glRenderbufferStorageMultisample",
"glFramebufferTextureLayer",
"glMapBufferRange",
"glFlushMappedBufferRange",
"glBindVertexArray",
"glDeleteVertexArrays",
"glGenVertexArrays",
"glIsVertexArray",
"glDrawArraysInstanced",
"glDrawElementsInstanced",
"glTexBuffer",
"glPrimitiveRestartIndex",
"glCopyBufferSubData",
"glGetUniformIndices",
"glGetActiveUniformsiv",
"glGetActiveUniformName",
"glGetUniformBlockIndex",
"glGetActiveUniformBlockiv",
"glGetActiveUniformBlockName",
"glUniformBlockBinding",
"glDrawElementsBaseVertex",
"glDrawRangeElementsBaseVertex",
"glDrawElementsInstancedBaseVertex",
"glMultiDrawElementsBaseVertex",
"glProvokingVertex",
"glFenceSync",
"glIsSync",
"glDeleteSync",
"glClientWaitSync",
"glWaitSync",
"glGetInteger64v",
"glGetSynciv",
"glGetInteger64i_v",
"glGetBufferParameteri64v",
"glFramebufferTexture",
"glTexImage2DMultisample",
"glTexImage3DMultisample",
"glGetMultisamplefv",
"glSampleMaski",
"glBindFragDataLocationIndexed",
"glGetFragDataIndex",
"glGenSamplers",
"glDeleteSamplers",
"glIsSampler",
"glBindSampler",
"glSamplerParameteri",
"glSamplerParameteriv",
"glSamplerParameterf",
"glSamplerParameterfv",
"glSamplerParameterIiv",
"glSamplerParameterIuiv",
"glGetSamplerParameteriv",
"glGetSamplerParameterIiv",
"glGetSamplerParameterfv",
"glGetSamplerParameterIuiv",
"glQueryCounter",
"glGetQueryObjecti64v",
"glGetQueryObjectui64v",
"glVertexAttribDivisor",
"glVertexAttribP1ui",
"glVertexAttribP1uiv",
"glVertexAttribP2ui",
"glVertexAttribP2uiv",
"glVertexAttribP3ui",
"glVertexAttribP3uiv",
"glVertexAttribP4ui",
"glVertexAttribP4uiv",
"glMinSampleShading",
"glBlendEquationi",
"glBlendEquationSeparatei",
"glBlendFunci",
"glBlendFuncSeparatei",
"glDrawArraysIndirect",
"glDrawElementsIndirect",
"glUniform1d",
"glUniform2d",
"glUniform3d",
"glUniform4d",
"glUniform1dv",
"glUniform2dv",
"glUniform3dv",
"glUniform4dv",
"glUniformMatrix2dv",
"glUniformMatrix3dv",
"glUniformMatrix4dv",
"glUniformMatrix2x3dv",
"glUniformMatrix2x4dv",
"glUniformMatrix3x2dv",
"glUniformMatrix3x4dv",
"glUniformMatrix4x2dv",
"glUniformMatrix4x3dv",
"glGetUniformdv",
"glGetSubroutineUniformLocation",
"glGetSubroutineIndex",
"glGetActiveSubroutineUniformiv",
"glGetActiveSubroutineUniformName",
"glGetActiveSubroutineName",
"glUniformSubroutinesuiv",
"glGetUniformSubroutineuiv",
"glGetProgramStageiv",
"glPatchParameteri",
"glPatchParameterfv",
"glBindTransformFeedback",
"glDeleteTransformFeedbacks",
"glGenTransformFeedbacks",
"glIsTransformFeedback",
"glPauseTransformFeedback",
"glResumeTransformFeedback",
"glDrawTransformFeedback",
"glDrawTransformFeedbackStream",
"glBeginQueryIndexed",
"glEndQueryIndexed",
"glGetQueryIndexediv",
"glReleaseShaderCompiler",
"glShaderBinary",
"glGetShaderPrecisionFormat",
"glDepthRangef",
"glClearDepthf",
"glGetProgramBinary",
"glProgramBinary",
"glProgramParameteri",
"glUseProgramStages",
"glActiveShaderProgram",
"glCreateShaderProgramv",
"glBindProgramPipeline",
"glDeleteProgramPipelines",
"glGenProgramPipelines",
"glIsProgramPipeline",
"glGetProgramPipelineiv",
"glProgramUniform1i",
"glProgramUniform1iv",
"glProgramUniform1f",
"glProgramUniform1fv",
"glProgramUniform1d",
"glProgramUniform1dv",
"glProgramUniform1ui",
"glProgramUniform1uiv",
"glProgramUniform2i",
"glProgramUniform2iv",
"glProgramUniform2f",
"glProgramUniform2fv",
"glProgramUniform2d",
"glProgramUniform2dv",
"glProgramUniform2ui",
"glProgramUniform2uiv",
"glProgramUniform3i",
"glProgramUniform3iv",
"glProgramUniform3f",
"glProgramUniform3fv",
"glProgramUniform3d",
"glProgramUniform3dv",
"glProgramUniform3ui",
"glProgramUniform3uiv",
"glProgramUniform4i",
"glProgramUniform4iv",
"glProgramUniform4f",
"glProgramUniform4fv",
"glProgramUniform4d",
"glProgramUniform4dv",
"glProgramUniform4ui",
"glProgramUniform4uiv",
"glProgramUniformMatrix2fv",
"glProgramUniformMatrix3fv",
"glProgramUniformMatrix4fv",
"glProgramUniformMatrix2dv",
"glProgramUniformMatrix3dv",
"glProgramUniformMatrix4dv",
"glProgramUniformMatrix2x3fv",
"glProgramUniformMatrix3x2fv",
"glProgramUniformMatrix2x4fv",
"glProgramUniformMatrix4x2fv",
"glProgramUniformMatrix3x4fv",
"glProgramUniformMatrix4x3fv",
"glProgramUniformMatrix2x3dv",
"glProgramUniformMatrix3x2dv",
"glProgramUniformMatrix2x4dv",
"glProgramUniformMatrix4x2dv",
"glProgramUniformMatrix3x4dv",
"glProgramUniformMatrix4x3dv",
"glValidateProgramPipeline",
"glGetProgramPipelineInfoLog",
"glVertexAttribL1d",
"glVertexAttribL2d",
"glVertexAttribL3d",
"glVertexAttribL4d",
"glVertexAttribL1dv",
"glVertexAttribL2dv",
"glVertexAttribL3dv",
"glVertexAttribL4dv",
"glVertexAttribLPointer",
"glGetVertexAttribLdv",
"glViewportArrayv",
"glViewportIndexedf",
"glViewportIndexedfv",
"glScissorArrayv",
"glScissorIndexed",
"glScissorIndexedv",
"glDepthRangeArrayv",
"glDepthRangeIndexed",
"glGetFloati_v",
"glGetDoublei_v",
"glDrawArraysInstancedBaseInstance",
"glDrawElementsInstancedBaseInstance",
"glDrawElementsInstancedBaseVertexBaseInstance",
"glGetInternalformativ",
"glGetActiveAtomicCounterBufferiv",
"glBindImageTexture",
"glMemoryBarrier",
"glTexStorage1D",
"glTexStorage2D",
"glTexStorage3D",
"glDrawTransformFeedbackInstanced",
"glDrawTransformFeedbackStreamInstanced",
"glClearBufferData",
"glClearBufferSubData",
"glDispatchCompute",
"glDispatchComputeIndirect",
"glCopyImageSubData",
"glFramebufferParameteri",
"glGetFramebufferParameteriv",
"glGetInternalformati64v",
"glInvalidateTexSubImage",
"glInvalidateTexImage",
"glInvalidateBufferSubData",
"glInvalidateBufferData",
"glInvalidateFramebuffer",
"glInvalidateSubFramebuffer",
"glMultiDrawArraysIndirect",
"glMultiDrawElementsIndirect",
"glGetProgramInterfaceiv",
"glGetProgramResourceIndex",
"glGetProgramResourceName",
"glGetProgramResourceiv",
"glGetProgramResourceLocation",
"glGetProgramResourceLocationIndex",
"glShaderStorageBlockBinding",
"glTexBufferRange",
"glTexStorage2DMultisample",
"glTexStorage3DMultisample",
"glTextureView",
"glBindVertexBuffer",
"glVertexAttribFormat",
"glVertexAttribIFormat",
"glVertexAttribLFormat",
"glVertexAttribBinding",
"glVertexBindingDivisor",
"glDebugMessageControl",
"glDebugMessageInsert",
"glDebugMessageCallback",
"glGetDebugMessageLog",
"glPushDebugGroup",
"glPopDebugGroup",
"glObjectLabel",
"glGetObjectLabel",
"glObjectPtrLabel",
"glGetObjectPtrLabel",
"glBufferStorage",
"glClearTexImage",
"glClearTexSubImage",
"glBindBuffersBase",
"glBindBuffersRange",
"glBindTextures",
"glBindSamplers",
"glBindImageTextures",
"glBindVertexBuffers",
"glClipControl",
"glCreateTransformFeedbacks",
"glTransformFeedbackBufferBase",
"glTransformFeedbackBufferRange",
"glGetTransformFeedbackiv",
"glGetTransformFeedbacki_v",
"glGetTransformFeedbacki64_v",
"glCreateBuffers",
"glNamedBufferStorage",
"glNamedBufferData",
"glNamedBufferSubData",
"glCopyNamedBufferSubData",
"glClearNamedBufferData",
"glClearNamedBufferSubData",
"glMapNamedBuffer",
"glMapNamedBufferRange",
"glUnmapNamedBuffer",
"glFlushMappedNamedBufferRange",
"glGetNamedBufferParameteriv",
"glGetNamedBufferParameteri64v",
"glGetNamedBufferPointerv",
"glGetNamedBufferSubData",
"glCreateFramebuffers",
"glNamedFramebufferRenderbuffer",
"glNamedFramebufferParameteri",
"glNamedFramebufferTexture",
"glNamedFramebufferTextureLayer",
"glNamedFramebufferDrawBuffer",
"glNamedFramebufferDrawBuffers",
"glNamedFramebufferReadBuffer",
"glInvalidateNamedFramebufferData",
"glInvalidateNamedFramebufferSubData",
"glClearNamedFramebufferiv",
"glClearNamedFramebufferuiv",
"glClearNamedFramebufferfv",
"glClearNamedFramebufferfi",
"glBlitNamedFramebuffer",
"glCheckNamedFramebufferStatus",
"glGetNamedFramebufferParameteriv",
"glGetNamedFramebufferAttachmentParameteriv",
"glCreateRenderbuffers",
"glNamedRenderbufferStorage",
"glNamedRenderbufferStorageMultisample",
"glGetNamedRenderbufferParameteriv",
"glCreateTextures",
"glTextureBuffer",
"glTextureBufferRange",
"glTextureStorage1D",
"glTextureStorage2D",
"glTextureStorage3D",
"glTextureStorage2DMultisample",
"glTextureStorage3DMultisample",
"glTextureSubImage1D",
"glTextureSubImage2D",
"glTextureSubImage3D",
"glCompressedTextureSubImage1D",
"glCompressedTextureSubImage2D",
"glCompressedTextureSubImage3D",
"glCopyTextureSubImage1D",
"glCopyTextureSubImage2D",
"glCopyTextureSubImage3D",
"glTextureParameterf",
"glTextureParameterfv",
"glTextureParameteri",
"glTextureParameterIiv",
"glTextureParameterIuiv",
"glTextureParameteriv",
"glGenerateTextureMipmap",
"glBindTextureUnit",
"glGetTextureImage",
"glGetCompressedTextureImage",
"glGetTextureLevelParameterfv",
"glGetTextureLevelParameteriv",
"glGetTextureParameterfv",
"glGetTextureParameterIiv",
"glGetTextureParameterIuiv",
"glGetTextureParameteriv",
"glCreateVertexArrays",
"glDisableVertexArrayAttrib",
"glEnableVertexArrayAttrib",
"glVertexArrayElementBuffer",
"glVertexArrayVertexBuffer",
"glVertexArrayVertexBuffers",
"glVertexArrayAttribBinding",
"glVertexArrayAttribFormat",
"glVertexArrayAttribIFormat",
"glVertexArrayAttribLFormat",
"glVertexArrayBindingDivisor",
"glGetVertexArrayiv",
"glGetVertexArrayIndexediv",
"glGetVertexArrayIndexed64iv",
"glCreateSamplers",
"glCreateProgramPipelines",
"glCreateQueries",
"glGetQueryBufferObjecti64v",
"glGetQueryBufferObjectiv",
"glGetQueryBufferObjectui64v",
"glGetQueryBufferObjectuiv",
"glMemoryBarrierByRegion",
"glGetTextureSubImage",
"glGetCompressedTextureSubImage",
"glGetGraphicsResetStatus",
"glGetnCompressedTexImage",
"glGetnTexImage",
"glGetnUniformdv",
"glGetnUniformfv",
"glGetnUniformiv",
"glGetnUniformuiv",
"glReadnPixels",
"glTextureBarrier",
"glSpecializeShader",
"glMultiDrawArraysIndirectCount",
"glMultiDrawElementsIndirectCount",
"glPolygonOffsetClamp"
};
}
}
@@ -0,0 +1,608 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Graphics
{
internal class GLexFunc_table
{
internal readonly gl.glDrawRangeElements glDrawRangeElements;
internal readonly gl.glTexImage3D glTexImage3D;
internal readonly gl.glTexSubImage3D glTexSubImage3D;
internal readonly gl.glCopyTexSubImage3D glCopyTexSubImage3D;
internal readonly gl.glActiveTexture glActiveTexture;
internal readonly gl.glSampleCoverage glSampleCoverage;
internal readonly gl.glCompressedTexImage3D glCompressedTexImage3D;
internal readonly gl.glCompressedTexImage2D glCompressedTexImage2D;
internal readonly gl.glCompressedTexImage1D glCompressedTexImage1D;
internal readonly gl.glCompressedTexSubImage3D glCompressedTexSubImage3D;
internal readonly gl.glCompressedTexSubImage2D glCompressedTexSubImage2D;
internal readonly gl.glCompressedTexSubImage1D glCompressedTexSubImage1D;
internal readonly gl.glGetCompressedTexImage glGetCompressedTexImage;
internal readonly gl.glBlendFuncSeparate glBlendFuncSeparate;
internal readonly gl.glMultiDrawArrays glMultiDrawArrays;
internal readonly gl.glMultiDrawElements glMultiDrawElements;
internal readonly gl.glPointParameterf glPointParameterf;
internal readonly gl.glPointParameterfv glPointParameterfv;
internal readonly gl.glPointParameteri glPointParameteri;
internal readonly gl.glPointParameteriv glPointParameteriv;
internal readonly gl.glBlendColor glBlendColor;
internal readonly gl.glBlendEquation glBlendEquation;
internal readonly gl.glGenQueries glGenQueries;
internal readonly gl.glDeleteQueries glDeleteQueries;
internal readonly gl.glIsQuery glIsQuery;
internal readonly gl.glBeginQuery glBeginQuery;
internal readonly gl.glEndQuery glEndQuery;
internal readonly gl.glGetQueryiv glGetQueryiv;
internal readonly gl.glGetQueryObjectiv glGetQueryObjectiv;
internal readonly gl.glGetQueryObjectuiv glGetQueryObjectuiv;
internal readonly gl.glBindBuffer glBindBuffer;
internal readonly gl.glDeleteBuffers glDeleteBuffers;
internal readonly gl.glGenBuffers glGenBuffers;
internal readonly gl.glIsBuffer glIsBuffer;
internal readonly gl.glBufferData glBufferData;
internal readonly gl.glBufferSubData glBufferSubData;
internal readonly gl.glGetBufferSubData glGetBufferSubData;
internal readonly gl.glMapBuffer glMapBuffer;
internal readonly gl.glUnmapBuffer glUnmapBuffer;
internal readonly gl.glGetBufferParameteriv glGetBufferParameteriv;
internal readonly gl.glGetBufferPointerv glGetBufferPointerv;
internal readonly gl.glBlendEquationSeparate glBlendEquationSeparate;
internal readonly gl.glDrawBuffers glDrawBuffers;
internal readonly gl.glStencilOpSeparate glStencilOpSeparate;
internal readonly gl.glStencilFuncSeparate glStencilFuncSeparate;
internal readonly gl.glStencilMaskSeparate glStencilMaskSeparate;
internal readonly gl.glAttachShader glAttachShader;
internal readonly gl.glBindAttribLocation glBindAttribLocation;
internal readonly gl.glCompileShader glCompileShader;
internal readonly gl.glCreateProgram glCreateProgram;
internal readonly gl.glCreateShader glCreateShader;
internal readonly gl.glDeleteProgram glDeleteProgram;
internal readonly gl.glDeleteShader glDeleteShader;
internal readonly gl.glDetachShader glDetachShader;
internal readonly gl.glDisableVertexAttribArray glDisableVertexAttribArray;
internal readonly gl.glEnableVertexAttribArray glEnableVertexAttribArray;
internal readonly gl.glGetActiveAttrib glGetActiveAttrib;
internal readonly gl.glGetActiveUniform glGetActiveUniform;
internal readonly gl.glGetAttachedShaders glGetAttachedShaders;
internal readonly gl.glGetAttribLocation glGetAttribLocation;
internal readonly gl.glGetProgramiv glGetProgramiv;
internal readonly gl.glGetProgramInfoLog glGetProgramInfoLog;
internal readonly gl.glGetShaderiv glGetShaderiv;
internal readonly gl.glGetShaderInfoLog glGetShaderInfoLog;
internal readonly gl.glGetShaderSource glGetShaderSource;
internal readonly gl.glGetUniformLocation glGetUniformLocation;
internal readonly gl.glGetUniformfv glGetUniformfv;
internal readonly gl.glGetUniformiv glGetUniformiv;
internal readonly gl.glGetVertexAttribdv glGetVertexAttribdv;
internal readonly gl.glGetVertexAttribfv glGetVertexAttribfv;
internal readonly gl.glGetVertexAttribiv glGetVertexAttribiv;
internal readonly gl.glGetVertexAttribPointerv glGetVertexAttribPointerv;
internal readonly gl.glIsProgram glIsProgram;
internal readonly gl.glIsShader glIsShader;
internal readonly gl.glLinkProgram glLinkProgram;
internal readonly gl.glShaderSource glShaderSource;
internal readonly gl.glUseProgram glUseProgram;
internal readonly gl.glUniform1f glUniform1f;
internal readonly gl.glUniform2f glUniform2f;
internal readonly gl.glUniform3f glUniform3f;
internal readonly gl.glUniform4f glUniform4f;
internal readonly gl.glUniform1i glUniform1i;
internal readonly gl.glUniform2i glUniform2i;
internal readonly gl.glUniform3i glUniform3i;
internal readonly gl.glUniform4i glUniform4i;
internal readonly gl.glUniform1fv glUniform1fv;
internal readonly gl.glUniform2fv glUniform2fv;
internal readonly gl.glUniform3fv glUniform3fv;
internal readonly gl.glUniform4fv glUniform4fv;
internal readonly gl.glUniform1iv glUniform1iv;
internal readonly gl.glUniform2iv glUniform2iv;
internal readonly gl.glUniform3iv glUniform3iv;
internal readonly gl.glUniform4iv glUniform4iv;
internal readonly gl.glUniformMatrix2fv glUniformMatrix2fv;
internal readonly gl.glUniformMatrix3fv glUniformMatrix3fv;
internal readonly gl.glUniformMatrix4fv glUniformMatrix4fv;
internal readonly gl.glValidateProgram glValidateProgram;
internal readonly gl.glVertexAttrib1d glVertexAttrib1d;
internal readonly gl.glVertexAttrib1dv glVertexAttrib1dv;
internal readonly gl.glVertexAttrib1f glVertexAttrib1f;
internal readonly gl.glVertexAttrib1fv glVertexAttrib1fv;
internal readonly gl.glVertexAttrib1s glVertexAttrib1s;
internal readonly gl.glVertexAttrib1sv glVertexAttrib1sv;
internal readonly gl.glVertexAttrib2d glVertexAttrib2d;
internal readonly gl.glVertexAttrib2dv glVertexAttrib2dv;
internal readonly gl.glVertexAttrib2f glVertexAttrib2f;
internal readonly gl.glVertexAttrib2fv glVertexAttrib2fv;
internal readonly gl.glVertexAttrib2s glVertexAttrib2s;
internal readonly gl.glVertexAttrib2sv glVertexAttrib2sv;
internal readonly gl.glVertexAttrib3d glVertexAttrib3d;
internal readonly gl.glVertexAttrib3dv glVertexAttrib3dv;
internal readonly gl.glVertexAttrib3f glVertexAttrib3f;
internal readonly gl.glVertexAttrib3fv glVertexAttrib3fv;
internal readonly gl.glVertexAttrib3s glVertexAttrib3s;
internal readonly gl.glVertexAttrib3sv glVertexAttrib3sv;
internal readonly gl.glVertexAttrib4Nbv glVertexAttrib4Nbv;
internal readonly gl.glVertexAttrib4Niv glVertexAttrib4Niv;
internal readonly gl.glVertexAttrib4Nsv glVertexAttrib4Nsv;
internal readonly gl.glVertexAttrib4Nub glVertexAttrib4Nub;
internal readonly gl.glVertexAttrib4Nubv glVertexAttrib4Nubv;
internal readonly gl.glVertexAttrib4Nuiv glVertexAttrib4Nuiv;
internal readonly gl.glVertexAttrib4Nusv glVertexAttrib4Nusv;
internal readonly gl.glVertexAttrib4bv glVertexAttrib4bv;
internal readonly gl.glVertexAttrib4d glVertexAttrib4d;
internal readonly gl.glVertexAttrib4dv glVertexAttrib4dv;
internal readonly gl.glVertexAttrib4f glVertexAttrib4f;
internal readonly gl.glVertexAttrib4fv glVertexAttrib4fv;
internal readonly gl.glVertexAttrib4iv glVertexAttrib4iv;
internal readonly gl.glVertexAttrib4s glVertexAttrib4s;
internal readonly gl.glVertexAttrib4sv glVertexAttrib4sv;
internal readonly gl.glVertexAttrib4ubv glVertexAttrib4ubv;
internal readonly gl.glVertexAttrib4uiv glVertexAttrib4uiv;
internal readonly gl.glVertexAttrib4usv glVertexAttrib4usv;
internal readonly gl.glVertexAttribPointer glVertexAttribPointer;
internal readonly gl.glUniformMatrix2x3fv glUniformMatrix2x3fv;
internal readonly gl.glUniformMatrix3x2fv glUniformMatrix3x2fv;
internal readonly gl.glUniformMatrix2x4fv glUniformMatrix2x4fv;
internal readonly gl.glUniformMatrix4x2fv glUniformMatrix4x2fv;
internal readonly gl.glUniformMatrix3x4fv glUniformMatrix3x4fv;
internal readonly gl.glUniformMatrix4x3fv glUniformMatrix4x3fv;
internal readonly gl.glColorMaski glColorMaski;
internal readonly gl.glGetBooleani_v glGetBooleani_v;
internal readonly gl.glGetIntegeri_v glGetIntegeri_v;
internal readonly gl.glEnablei glEnablei;
internal readonly gl.glDisablei glDisablei;
internal readonly gl.glIsEnabledi glIsEnabledi;
internal readonly gl.glBeginTransformFeedback glBeginTransformFeedback;
internal readonly gl.glEndTransformFeedback glEndTransformFeedback;
internal readonly gl.glBindBufferRange glBindBufferRange;
internal readonly gl.glBindBufferBase glBindBufferBase;
internal readonly gl.glTransformFeedbackVaryings glTransformFeedbackVaryings;
internal readonly gl.glGetTransformFeedbackVarying glGetTransformFeedbackVarying;
internal readonly gl.glClampColor glClampColor;
internal readonly gl.glBeginConditionalRender glBeginConditionalRender;
internal readonly gl.glEndConditionalRender glEndConditionalRender;
internal readonly gl.glVertexAttribIPointer glVertexAttribIPointer;
internal readonly gl.glGetVertexAttribIiv glGetVertexAttribIiv;
internal readonly gl.glGetVertexAttribIuiv glGetVertexAttribIuiv;
internal readonly gl.glVertexAttribI1i glVertexAttribI1i;
internal readonly gl.glVertexAttribI2i glVertexAttribI2i;
internal readonly gl.glVertexAttribI3i glVertexAttribI3i;
internal readonly gl.glVertexAttribI4i glVertexAttribI4i;
internal readonly gl.glVertexAttribI1ui glVertexAttribI1ui;
internal readonly gl.glVertexAttribI2ui glVertexAttribI2ui;
internal readonly gl.glVertexAttribI3ui glVertexAttribI3ui;
internal readonly gl.glVertexAttribI4ui glVertexAttribI4ui;
internal readonly gl.glVertexAttribI1iv glVertexAttribI1iv;
internal readonly gl.glVertexAttribI2iv glVertexAttribI2iv;
internal readonly gl.glVertexAttribI3iv glVertexAttribI3iv;
internal readonly gl.glVertexAttribI4iv glVertexAttribI4iv;
internal readonly gl.glVertexAttribI1uiv glVertexAttribI1uiv;
internal readonly gl.glVertexAttribI2uiv glVertexAttribI2uiv;
internal readonly gl.glVertexAttribI3uiv glVertexAttribI3uiv;
internal readonly gl.glVertexAttribI4uiv glVertexAttribI4uiv;
internal readonly gl.glVertexAttribI4bv glVertexAttribI4bv;
internal readonly gl.glVertexAttribI4sv glVertexAttribI4sv;
internal readonly gl.glVertexAttribI4ubv glVertexAttribI4ubv;
internal readonly gl.glVertexAttribI4usv glVertexAttribI4usv;
internal readonly gl.glGetUniformuiv glGetUniformuiv;
internal readonly gl.glBindFragDataLocation glBindFragDataLocation;
internal readonly gl.glGetFragDataLocation glGetFragDataLocation;
internal readonly gl.glUniform1ui glUniform1ui;
internal readonly gl.glUniform2ui glUniform2ui;
internal readonly gl.glUniform3ui glUniform3ui;
internal readonly gl.glUniform4ui glUniform4ui;
internal readonly gl.glUniform1uiv glUniform1uiv;
internal readonly gl.glUniform2uiv glUniform2uiv;
internal readonly gl.glUniform3uiv glUniform3uiv;
internal readonly gl.glUniform4uiv glUniform4uiv;
internal readonly gl.glTexParameterIiv glTexParameterIiv;
internal readonly gl.glTexParameterIuiv glTexParameterIuiv;
internal readonly gl.glGetTexParameterIiv glGetTexParameterIiv;
internal readonly gl.glGetTexParameterIuiv glGetTexParameterIuiv;
internal readonly gl.glClearBufferiv glClearBufferiv;
internal readonly gl.glClearBufferuiv glClearBufferuiv;
internal readonly gl.glClearBufferfv glClearBufferfv;
internal readonly gl.glClearBufferfi glClearBufferfi;
internal readonly gl.glGetStringi glGetStringi;
internal readonly gl.glIsRenderbuffer glIsRenderbuffer;
internal readonly gl.glBindRenderbuffer glBindRenderbuffer;
internal readonly gl.glDeleteRenderbuffers glDeleteRenderbuffers;
internal readonly gl.glGenRenderbuffers glGenRenderbuffers;
internal readonly gl.glRenderbufferStorage glRenderbufferStorage;
internal readonly gl.glGetRenderbufferParameteriv glGetRenderbufferParameteriv;
internal readonly gl.glIsFramebuffer glIsFramebuffer;
internal readonly gl.glBindFramebuffer glBindFramebuffer;
internal readonly gl.glDeleteFramebuffers glDeleteFramebuffers;
internal readonly gl.glGenFramebuffers glGenFramebuffers;
internal readonly gl.glCheckFramebufferStatus glCheckFramebufferStatus;
internal readonly gl.glFramebufferTexture1D glFramebufferTexture1D;
internal readonly gl.glFramebufferTexture2D glFramebufferTexture2D;
internal readonly gl.glFramebufferTexture3D glFramebufferTexture3D;
internal readonly gl.glFramebufferRenderbuffer glFramebufferRenderbuffer;
internal readonly gl.glGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameteriv;
internal readonly gl.glGenerateMipmap glGenerateMipmap;
internal readonly gl.glBlitFramebuffer glBlitFramebuffer;
internal readonly gl.glRenderbufferStorageMultisample glRenderbufferStorageMultisample;
internal readonly gl.glFramebufferTextureLayer glFramebufferTextureLayer;
internal readonly gl.glMapBufferRange glMapBufferRange;
internal readonly gl.glFlushMappedBufferRange glFlushMappedBufferRange;
internal readonly gl.glBindVertexArray glBindVertexArray;
internal readonly gl.glDeleteVertexArrays glDeleteVertexArrays;
internal readonly gl.glGenVertexArrays glGenVertexArrays;
internal readonly gl.glIsVertexArray glIsVertexArray;
internal readonly gl.glDrawArraysInstanced glDrawArraysInstanced;
internal readonly gl.glDrawElementsInstanced glDrawElementsInstanced;
internal readonly gl.glTexBuffer glTexBuffer;
internal readonly gl.glPrimitiveRestartIndex glPrimitiveRestartIndex;
internal readonly gl.glCopyBufferSubData glCopyBufferSubData;
internal readonly gl.glGetUniformIndices glGetUniformIndices;
internal readonly gl.glGetActiveUniformsiv glGetActiveUniformsiv;
internal readonly gl.glGetActiveUniformName glGetActiveUniformName;
internal readonly gl.glGetUniformBlockIndex glGetUniformBlockIndex;
internal readonly gl.glGetActiveUniformBlockiv glGetActiveUniformBlockiv;
internal readonly gl.glGetActiveUniformBlockName glGetActiveUniformBlockName;
internal readonly gl.glUniformBlockBinding glUniformBlockBinding;
internal readonly gl.glDrawElementsBaseVertex glDrawElementsBaseVertex;
internal readonly gl.glDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex;
internal readonly gl.glDrawElementsInstancedBaseVertex glDrawElementsInstancedBaseVertex;
internal readonly gl.glMultiDrawElementsBaseVertex glMultiDrawElementsBaseVertex;
internal readonly gl.glProvokingVertex glProvokingVertex;
internal readonly gl.glFenceSync glFenceSync;
internal readonly gl.glIsSync glIsSync;
internal readonly gl.glDeleteSync glDeleteSync;
internal readonly gl.glClientWaitSync glClientWaitSync;
internal readonly gl.glWaitSync glWaitSync;
internal readonly gl.glGetInteger64v glGetInteger64v;
internal readonly gl.glGetSynciv glGetSynciv;
internal readonly gl.glGetInteger64i_v glGetInteger64i_v;
internal readonly gl.glGetBufferParameteri64v glGetBufferParameteri64v;
internal readonly gl.glFramebufferTexture glFramebufferTexture;
internal readonly gl.glTexImage2DMultisample glTexImage2DMultisample;
internal readonly gl.glTexImage3DMultisample glTexImage3DMultisample;
internal readonly gl.glGetMultisamplefv glGetMultisamplefv;
internal readonly gl.glSampleMaski glSampleMaski;
internal readonly gl.glBindFragDataLocationIndexed glBindFragDataLocationIndexed;
internal readonly gl.glGetFragDataIndex glGetFragDataIndex;
internal readonly gl.glGenSamplers glGenSamplers;
internal readonly gl.glDeleteSamplers glDeleteSamplers;
internal readonly gl.glIsSampler glIsSampler;
internal readonly gl.glBindSampler glBindSampler;
internal readonly gl.glSamplerParameteri glSamplerParameteri;
internal readonly gl.glSamplerParameteriv glSamplerParameteriv;
internal readonly gl.glSamplerParameterf glSamplerParameterf;
internal readonly gl.glSamplerParameterfv glSamplerParameterfv;
internal readonly gl.glSamplerParameterIiv glSamplerParameterIiv;
internal readonly gl.glSamplerParameterIuiv glSamplerParameterIuiv;
internal readonly gl.glGetSamplerParameteriv glGetSamplerParameteriv;
internal readonly gl.glGetSamplerParameterIiv glGetSamplerParameterIiv;
internal readonly gl.glGetSamplerParameterfv glGetSamplerParameterfv;
internal readonly gl.glGetSamplerParameterIuiv glGetSamplerParameterIuiv;
internal readonly gl.glQueryCounter glQueryCounter;
internal readonly gl.glGetQueryObjecti64v glGetQueryObjecti64v;
internal readonly gl.glGetQueryObjectui64v glGetQueryObjectui64v;
internal readonly gl.glVertexAttribDivisor glVertexAttribDivisor;
internal readonly gl.glVertexAttribP1ui glVertexAttribP1ui;
internal readonly gl.glVertexAttribP1uiv glVertexAttribP1uiv;
internal readonly gl.glVertexAttribP2ui glVertexAttribP2ui;
internal readonly gl.glVertexAttribP2uiv glVertexAttribP2uiv;
internal readonly gl.glVertexAttribP3ui glVertexAttribP3ui;
internal readonly gl.glVertexAttribP3uiv glVertexAttribP3uiv;
internal readonly gl.glVertexAttribP4ui glVertexAttribP4ui;
internal readonly gl.glVertexAttribP4uiv glVertexAttribP4uiv;
internal readonly gl.glMinSampleShading glMinSampleShading;
internal readonly gl.glBlendEquationi glBlendEquationi;
internal readonly gl.glBlendEquationSeparatei glBlendEquationSeparatei;
internal readonly gl.glBlendFunci glBlendFunci;
internal readonly gl.glBlendFuncSeparatei glBlendFuncSeparatei;
internal readonly gl.glDrawArraysIndirect glDrawArraysIndirect;
internal readonly gl.glDrawElementsIndirect glDrawElementsIndirect;
internal readonly gl.glUniform1d glUniform1d;
internal readonly gl.glUniform2d glUniform2d;
internal readonly gl.glUniform3d glUniform3d;
internal readonly gl.glUniform4d glUniform4d;
internal readonly gl.glUniform1dv glUniform1dv;
internal readonly gl.glUniform2dv glUniform2dv;
internal readonly gl.glUniform3dv glUniform3dv;
internal readonly gl.glUniform4dv glUniform4dv;
internal readonly gl.glUniformMatrix2dv glUniformMatrix2dv;
internal readonly gl.glUniformMatrix3dv glUniformMatrix3dv;
internal readonly gl.glUniformMatrix4dv glUniformMatrix4dv;
internal readonly gl.glUniformMatrix2x3dv glUniformMatrix2x3dv;
internal readonly gl.glUniformMatrix2x4dv glUniformMatrix2x4dv;
internal readonly gl.glUniformMatrix3x2dv glUniformMatrix3x2dv;
internal readonly gl.glUniformMatrix3x4dv glUniformMatrix3x4dv;
internal readonly gl.glUniformMatrix4x2dv glUniformMatrix4x2dv;
internal readonly gl.glUniformMatrix4x3dv glUniformMatrix4x3dv;
internal readonly gl.glGetUniformdv glGetUniformdv;
internal readonly gl.glGetSubroutineUniformLocation glGetSubroutineUniformLocation;
internal readonly gl.glGetSubroutineIndex glGetSubroutineIndex;
internal readonly gl.glGetActiveSubroutineUniformiv glGetActiveSubroutineUniformiv;
internal readonly gl.glGetActiveSubroutineUniformName glGetActiveSubroutineUniformName;
internal readonly gl.glGetActiveSubroutineName glGetActiveSubroutineName;
internal readonly gl.glUniformSubroutinesuiv glUniformSubroutinesuiv;
internal readonly gl.glGetUniformSubroutineuiv glGetUniformSubroutineuiv;
internal readonly gl.glGetProgramStageiv glGetProgramStageiv;
internal readonly gl.glPatchParameteri glPatchParameteri;
internal readonly gl.glPatchParameterfv glPatchParameterfv;
internal readonly gl.glBindTransformFeedback glBindTransformFeedback;
internal readonly gl.glDeleteTransformFeedbacks glDeleteTransformFeedbacks;
internal readonly gl.glGenTransformFeedbacks glGenTransformFeedbacks;
internal readonly gl.glIsTransformFeedback glIsTransformFeedback;
internal readonly gl.glPauseTransformFeedback glPauseTransformFeedback;
internal readonly gl.glResumeTransformFeedback glResumeTransformFeedback;
internal readonly gl.glDrawTransformFeedback glDrawTransformFeedback;
internal readonly gl.glDrawTransformFeedbackStream glDrawTransformFeedbackStream;
internal readonly gl.glBeginQueryIndexed glBeginQueryIndexed;
internal readonly gl.glEndQueryIndexed glEndQueryIndexed;
internal readonly gl.glGetQueryIndexediv glGetQueryIndexediv;
internal readonly gl.glReleaseShaderCompiler glReleaseShaderCompiler;
internal readonly gl.glShaderBinary glShaderBinary;
internal readonly gl.glGetShaderPrecisionFormat glGetShaderPrecisionFormat;
internal readonly gl.glDepthRangef glDepthRangef;
internal readonly gl.glClearDepthf glClearDepthf;
internal readonly gl.glGetProgramBinary glGetProgramBinary;
internal readonly gl.glProgramBinary glProgramBinary;
internal readonly gl.glProgramParameteri glProgramParameteri;
internal readonly gl.glUseProgramStages glUseProgramStages;
internal readonly gl.glActiveShaderProgram glActiveShaderProgram;
internal readonly gl.glCreateShaderProgramv glCreateShaderProgramv;
internal readonly gl.glBindProgramPipeline glBindProgramPipeline;
internal readonly gl.glDeleteProgramPipelines glDeleteProgramPipelines;
internal readonly gl.glGenProgramPipelines glGenProgramPipelines;
internal readonly gl.glIsProgramPipeline glIsProgramPipeline;
internal readonly gl.glGetProgramPipelineiv glGetProgramPipelineiv;
internal readonly gl.glProgramUniform1i glProgramUniform1i;
internal readonly gl.glProgramUniform1iv glProgramUniform1iv;
internal readonly gl.glProgramUniform1f glProgramUniform1f;
internal readonly gl.glProgramUniform1fv glProgramUniform1fv;
internal readonly gl.glProgramUniform1d glProgramUniform1d;
internal readonly gl.glProgramUniform1dv glProgramUniform1dv;
internal readonly gl.glProgramUniform1ui glProgramUniform1ui;
internal readonly gl.glProgramUniform1uiv glProgramUniform1uiv;
internal readonly gl.glProgramUniform2i glProgramUniform2i;
internal readonly gl.glProgramUniform2iv glProgramUniform2iv;
internal readonly gl.glProgramUniform2f glProgramUniform2f;
internal readonly gl.glProgramUniform2fv glProgramUniform2fv;
internal readonly gl.glProgramUniform2d glProgramUniform2d;
internal readonly gl.glProgramUniform2dv glProgramUniform2dv;
internal readonly gl.glProgramUniform2ui glProgramUniform2ui;
internal readonly gl.glProgramUniform2uiv glProgramUniform2uiv;
internal readonly gl.glProgramUniform3i glProgramUniform3i;
internal readonly gl.glProgramUniform3iv glProgramUniform3iv;
internal readonly gl.glProgramUniform3f glProgramUniform3f;
internal readonly gl.glProgramUniform3fv glProgramUniform3fv;
internal readonly gl.glProgramUniform3d glProgramUniform3d;
internal readonly gl.glProgramUniform3dv glProgramUniform3dv;
internal readonly gl.glProgramUniform3ui glProgramUniform3ui;
internal readonly gl.glProgramUniform3uiv glProgramUniform3uiv;
internal readonly gl.glProgramUniform4i glProgramUniform4i;
internal readonly gl.glProgramUniform4iv glProgramUniform4iv;
internal readonly gl.glProgramUniform4f glProgramUniform4f;
internal readonly gl.glProgramUniform4fv glProgramUniform4fv;
internal readonly gl.glProgramUniform4d glProgramUniform4d;
internal readonly gl.glProgramUniform4dv glProgramUniform4dv;
internal readonly gl.glProgramUniform4ui glProgramUniform4ui;
internal readonly gl.glProgramUniform4uiv glProgramUniform4uiv;
internal readonly gl.glProgramUniformMatrix2fv glProgramUniformMatrix2fv;
internal readonly gl.glProgramUniformMatrix3fv glProgramUniformMatrix3fv;
internal readonly gl.glProgramUniformMatrix4fv glProgramUniformMatrix4fv;
internal readonly gl.glProgramUniformMatrix2dv glProgramUniformMatrix2dv;
internal readonly gl.glProgramUniformMatrix3dv glProgramUniformMatrix3dv;
internal readonly gl.glProgramUniformMatrix4dv glProgramUniformMatrix4dv;
internal readonly gl.glProgramUniformMatrix2x3fv glProgramUniformMatrix2x3fv;
internal readonly gl.glProgramUniformMatrix3x2fv glProgramUniformMatrix3x2fv;
internal readonly gl.glProgramUniformMatrix2x4fv glProgramUniformMatrix2x4fv;
internal readonly gl.glProgramUniformMatrix4x2fv glProgramUniformMatrix4x2fv;
internal readonly gl.glProgramUniformMatrix3x4fv glProgramUniformMatrix3x4fv;
internal readonly gl.glProgramUniformMatrix4x3fv glProgramUniformMatrix4x3fv;
internal readonly gl.glProgramUniformMatrix2x3dv glProgramUniformMatrix2x3dv;
internal readonly gl.glProgramUniformMatrix3x2dv glProgramUniformMatrix3x2dv;
internal readonly gl.glProgramUniformMatrix2x4dv glProgramUniformMatrix2x4dv;
internal readonly gl.glProgramUniformMatrix4x2dv glProgramUniformMatrix4x2dv;
internal readonly gl.glProgramUniformMatrix3x4dv glProgramUniformMatrix3x4dv;
internal readonly gl.glProgramUniformMatrix4x3dv glProgramUniformMatrix4x3dv;
internal readonly gl.glValidateProgramPipeline glValidateProgramPipeline;
internal readonly gl.glGetProgramPipelineInfoLog glGetProgramPipelineInfoLog;
internal readonly gl.glVertexAttribL1d glVertexAttribL1d;
internal readonly gl.glVertexAttribL2d glVertexAttribL2d;
internal readonly gl.glVertexAttribL3d glVertexAttribL3d;
internal readonly gl.glVertexAttribL4d glVertexAttribL4d;
internal readonly gl.glVertexAttribL1dv glVertexAttribL1dv;
internal readonly gl.glVertexAttribL2dv glVertexAttribL2dv;
internal readonly gl.glVertexAttribL3dv glVertexAttribL3dv;
internal readonly gl.glVertexAttribL4dv glVertexAttribL4dv;
internal readonly gl.glVertexAttribLPointer glVertexAttribLPointer;
internal readonly gl.glGetVertexAttribLdv glGetVertexAttribLdv;
internal readonly gl.glViewportArrayv glViewportArrayv;
internal readonly gl.glViewportIndexedf glViewportIndexedf;
internal readonly gl.glViewportIndexedfv glViewportIndexedfv;
internal readonly gl.glScissorArrayv glScissorArrayv;
internal readonly gl.glScissorIndexed glScissorIndexed;
internal readonly gl.glScissorIndexedv glScissorIndexedv;
internal readonly gl.glDepthRangeArrayv glDepthRangeArrayv;
internal readonly gl.glDepthRangeIndexed glDepthRangeIndexed;
internal readonly gl.glGetFloati_v glGetFloati_v;
internal readonly gl.glGetDoublei_v glGetDoublei_v;
internal readonly gl.glDrawArraysInstancedBaseInstance glDrawArraysInstancedBaseInstance;
internal readonly gl.glDrawElementsInstancedBaseInstance glDrawElementsInstancedBaseInstance;
internal readonly gl.glDrawElementsInstancedBaseVertexBaseInstance glDrawElementsInstancedBaseVertexBaseInstance;
internal readonly gl.glGetInternalformativ glGetInternalformativ;
internal readonly gl.glGetActiveAtomicCounterBufferiv glGetActiveAtomicCounterBufferiv;
internal readonly gl.glBindImageTexture glBindImageTexture;
internal readonly gl.glMemoryBarrier glMemoryBarrier;
internal readonly gl.glTexStorage1D glTexStorage1D;
internal readonly gl.glTexStorage2D glTexStorage2D;
internal readonly gl.glTexStorage3D glTexStorage3D;
internal readonly gl.glDrawTransformFeedbackInstanced glDrawTransformFeedbackInstanced;
internal readonly gl.glDrawTransformFeedbackStreamInstanced glDrawTransformFeedbackStreamInstanced;
internal readonly gl.glClearBufferData glClearBufferData;
internal readonly gl.glClearBufferSubData glClearBufferSubData;
internal readonly gl.glDispatchCompute glDispatchCompute;
internal readonly gl.glDispatchComputeIndirect glDispatchComputeIndirect;
internal readonly gl.glCopyImageSubData glCopyImageSubData;
internal readonly gl.glFramebufferParameteri glFramebufferParameteri;
internal readonly gl.glGetFramebufferParameteriv glGetFramebufferParameteriv;
internal readonly gl.glGetInternalformati64v glGetInternalformati64v;
internal readonly gl.glInvalidateTexSubImage glInvalidateTexSubImage;
internal readonly gl.glInvalidateTexImage glInvalidateTexImage;
internal readonly gl.glInvalidateBufferSubData glInvalidateBufferSubData;
internal readonly gl.glInvalidateBufferData glInvalidateBufferData;
internal readonly gl.glInvalidateFramebuffer glInvalidateFramebuffer;
internal readonly gl.glInvalidateSubFramebuffer glInvalidateSubFramebuffer;
internal readonly gl.glMultiDrawArraysIndirect glMultiDrawArraysIndirect;
internal readonly gl.glMultiDrawElementsIndirect glMultiDrawElementsIndirect;
internal readonly gl.glGetProgramInterfaceiv glGetProgramInterfaceiv;
internal readonly gl.glGetProgramResourceIndex glGetProgramResourceIndex;
internal readonly gl.glGetProgramResourceName glGetProgramResourceName;
internal readonly gl.glGetProgramResourceiv glGetProgramResourceiv;
internal readonly gl.glGetProgramResourceLocation glGetProgramResourceLocation;
internal readonly gl.glGetProgramResourceLocationIndex glGetProgramResourceLocationIndex;
internal readonly gl.glShaderStorageBlockBinding glShaderStorageBlockBinding;
internal readonly gl.glTexBufferRange glTexBufferRange;
internal readonly gl.glTexStorage2DMultisample glTexStorage2DMultisample;
internal readonly gl.glTexStorage3DMultisample glTexStorage3DMultisample;
internal readonly gl.glTextureView glTextureView;
internal readonly gl.glBindVertexBuffer glBindVertexBuffer;
internal readonly gl.glVertexAttribFormat glVertexAttribFormat;
internal readonly gl.glVertexAttribIFormat glVertexAttribIFormat;
internal readonly gl.glVertexAttribLFormat glVertexAttribLFormat;
internal readonly gl.glVertexAttribBinding glVertexAttribBinding;
internal readonly gl.glVertexBindingDivisor glVertexBindingDivisor;
internal readonly gl.glDebugMessageControl glDebugMessageControl;
internal readonly gl.glDebugMessageInsert glDebugMessageInsert;
internal readonly gl.glDebugMessageCallback glDebugMessageCallback;
internal readonly gl.glGetDebugMessageLog glGetDebugMessageLog;
internal readonly gl.glPushDebugGroup glPushDebugGroup;
internal readonly gl.glPopDebugGroup glPopDebugGroup;
internal readonly gl.glObjectLabel glObjectLabel;
internal readonly gl.glGetObjectLabel glGetObjectLabel;
internal readonly gl.glObjectPtrLabel glObjectPtrLabel;
internal readonly gl.glGetObjectPtrLabel glGetObjectPtrLabel;
internal readonly gl.glBufferStorage glBufferStorage;
internal readonly gl.glClearTexImage glClearTexImage;
internal readonly gl.glClearTexSubImage glClearTexSubImage;
internal readonly gl.glBindBuffersBase glBindBuffersBase;
internal readonly gl.glBindBuffersRange glBindBuffersRange;
internal readonly gl.glBindTextures glBindTextures;
internal readonly gl.glBindSamplers glBindSamplers;
internal readonly gl.glBindImageTextures glBindImageTextures;
internal readonly gl.glBindVertexBuffers glBindVertexBuffers;
internal readonly gl.glClipControl glClipControl;
internal readonly gl.glCreateTransformFeedbacks glCreateTransformFeedbacks;
internal readonly gl.glTransformFeedbackBufferBase glTransformFeedbackBufferBase;
internal readonly gl.glTransformFeedbackBufferRange glTransformFeedbackBufferRange;
internal readonly gl.glGetTransformFeedbackiv glGetTransformFeedbackiv;
internal readonly gl.glGetTransformFeedbacki_v glGetTransformFeedbacki_v;
internal readonly gl.glGetTransformFeedbacki64_v glGetTransformFeedbacki64_v;
internal readonly gl.glCreateBuffers glCreateBuffers;
internal readonly gl.glNamedBufferStorage glNamedBufferStorage;
internal readonly gl.glNamedBufferData glNamedBufferData;
internal readonly gl.glNamedBufferSubData glNamedBufferSubData;
internal readonly gl.glCopyNamedBufferSubData glCopyNamedBufferSubData;
internal readonly gl.glClearNamedBufferData glClearNamedBufferData;
internal readonly gl.glClearNamedBufferSubData glClearNamedBufferSubData;
internal readonly gl.glMapNamedBuffer glMapNamedBuffer;
internal readonly gl.glMapNamedBufferRange glMapNamedBufferRange;
internal readonly gl.glUnmapNamedBuffer glUnmapNamedBuffer;
internal readonly gl.glFlushMappedNamedBufferRange glFlushMappedNamedBufferRange;
internal readonly gl.glGetNamedBufferParameteriv glGetNamedBufferParameteriv;
internal readonly gl.glGetNamedBufferParameteri64v glGetNamedBufferParameteri64v;
internal readonly gl.glGetNamedBufferPointerv glGetNamedBufferPointerv;
internal readonly gl.glGetNamedBufferSubData glGetNamedBufferSubData;
internal readonly gl.glCreateFramebuffers glCreateFramebuffers;
internal readonly gl.glNamedFramebufferRenderbuffer glNamedFramebufferRenderbuffer;
internal readonly gl.glNamedFramebufferParameteri glNamedFramebufferParameteri;
internal readonly gl.glNamedFramebufferTexture glNamedFramebufferTexture;
internal readonly gl.glNamedFramebufferTextureLayer glNamedFramebufferTextureLayer;
internal readonly gl.glNamedFramebufferDrawBuffer glNamedFramebufferDrawBuffer;
internal readonly gl.glNamedFramebufferDrawBuffers glNamedFramebufferDrawBuffers;
internal readonly gl.glNamedFramebufferReadBuffer glNamedFramebufferReadBuffer;
internal readonly gl.glInvalidateNamedFramebufferData glInvalidateNamedFramebufferData;
internal readonly gl.glInvalidateNamedFramebufferSubData glInvalidateNamedFramebufferSubData;
internal readonly gl.glClearNamedFramebufferiv glClearNamedFramebufferiv;
internal readonly gl.glClearNamedFramebufferuiv glClearNamedFramebufferuiv;
internal readonly gl.glClearNamedFramebufferfv glClearNamedFramebufferfv;
internal readonly gl.glClearNamedFramebufferfi glClearNamedFramebufferfi;
internal readonly gl.glBlitNamedFramebuffer glBlitNamedFramebuffer;
internal readonly gl.glCheckNamedFramebufferStatus glCheckNamedFramebufferStatus;
internal readonly gl.glGetNamedFramebufferParameteriv glGetNamedFramebufferParameteriv;
internal readonly gl.glGetNamedFramebufferAttachmentParameteriv glGetNamedFramebufferAttachmentParameteriv;
internal readonly gl.glCreateRenderbuffers glCreateRenderbuffers;
internal readonly gl.glNamedRenderbufferStorage glNamedRenderbufferStorage;
internal readonly gl.glNamedRenderbufferStorageMultisample glNamedRenderbufferStorageMultisample;
internal readonly gl.glGetNamedRenderbufferParameteriv glGetNamedRenderbufferParameteriv;
internal readonly gl.glCreateTextures glCreateTextures;
internal readonly gl.glTextureBuffer glTextureBuffer;
internal readonly gl.glTextureBufferRange glTextureBufferRange;
internal readonly gl.glTextureStorage1D glTextureStorage1D;
internal readonly gl.glTextureStorage2D glTextureStorage2D;
internal readonly gl.glTextureStorage3D glTextureStorage3D;
internal readonly gl.glTextureStorage2DMultisample glTextureStorage2DMultisample;
internal readonly gl.glTextureStorage3DMultisample glTextureStorage3DMultisample;
internal readonly gl.glTextureSubImage1D glTextureSubImage1D;
internal readonly gl.glTextureSubImage2D glTextureSubImage2D;
internal readonly gl.glTextureSubImage3D glTextureSubImage3D;
internal readonly gl.glCompressedTextureSubImage1D glCompressedTextureSubImage1D;
internal readonly gl.glCompressedTextureSubImage2D glCompressedTextureSubImage2D;
internal readonly gl.glCompressedTextureSubImage3D glCompressedTextureSubImage3D;
internal readonly gl.glCopyTextureSubImage1D glCopyTextureSubImage1D;
internal readonly gl.glCopyTextureSubImage2D glCopyTextureSubImage2D;
internal readonly gl.glCopyTextureSubImage3D glCopyTextureSubImage3D;
internal readonly gl.glTextureParameterf glTextureParameterf;
internal readonly gl.glTextureParameterfv glTextureParameterfv;
internal readonly gl.glTextureParameteri glTextureParameteri;
internal readonly gl.glTextureParameterIiv glTextureParameterIiv;
internal readonly gl.glTextureParameterIuiv glTextureParameterIuiv;
internal readonly gl.glTextureParameteriv glTextureParameteriv;
internal readonly gl.glGenerateTextureMipmap glGenerateTextureMipmap;
internal readonly gl.glBindTextureUnit glBindTextureUnit;
internal readonly gl.glGetTextureImage glGetTextureImage;
internal readonly gl.glGetCompressedTextureImage glGetCompressedTextureImage;
internal readonly gl.glGetTextureLevelParameterfv glGetTextureLevelParameterfv;
internal readonly gl.glGetTextureLevelParameteriv glGetTextureLevelParameteriv;
internal readonly gl.glGetTextureParameterfv glGetTextureParameterfv;
internal readonly gl.glGetTextureParameterIiv glGetTextureParameterIiv;
internal readonly gl.glGetTextureParameterIuiv glGetTextureParameterIuiv;
internal readonly gl.glGetTextureParameteriv glGetTextureParameteriv;
internal readonly gl.glCreateVertexArrays glCreateVertexArrays;
internal readonly gl.glDisableVertexArrayAttrib glDisableVertexArrayAttrib;
internal readonly gl.glEnableVertexArrayAttrib glEnableVertexArrayAttrib;
internal readonly gl.glVertexArrayElementBuffer glVertexArrayElementBuffer;
internal readonly gl.glVertexArrayVertexBuffer glVertexArrayVertexBuffer;
internal readonly gl.glVertexArrayVertexBuffers glVertexArrayVertexBuffers;
internal readonly gl.glVertexArrayAttribBinding glVertexArrayAttribBinding;
internal readonly gl.glVertexArrayAttribFormat glVertexArrayAttribFormat;
internal readonly gl.glVertexArrayAttribIFormat glVertexArrayAttribIFormat;
internal readonly gl.glVertexArrayAttribLFormat glVertexArrayAttribLFormat;
internal readonly gl.glVertexArrayBindingDivisor glVertexArrayBindingDivisor;
internal readonly gl.glGetVertexArrayiv glGetVertexArrayiv;
internal readonly gl.glGetVertexArrayIndexediv glGetVertexArrayIndexediv;
internal readonly gl.glGetVertexArrayIndexed64iv glGetVertexArrayIndexed64iv;
internal readonly gl.glCreateSamplers glCreateSamplers;
internal readonly gl.glCreateProgramPipelines glCreateProgramPipelines;
internal readonly gl.glCreateQueries glCreateQueries;
internal readonly gl.glGetQueryBufferObjecti64v glGetQueryBufferObjecti64v;
internal readonly gl.glGetQueryBufferObjectiv glGetQueryBufferObjectiv;
internal readonly gl.glGetQueryBufferObjectui64v glGetQueryBufferObjectui64v;
internal readonly gl.glGetQueryBufferObjectuiv glGetQueryBufferObjectuiv;
internal readonly gl.glMemoryBarrierByRegion glMemoryBarrierByRegion;
internal readonly gl.glGetTextureSubImage glGetTextureSubImage;
internal readonly gl.glGetCompressedTextureSubImage glGetCompressedTextureSubImage;
internal readonly gl.glGetGraphicsResetStatus glGetGraphicsResetStatus;
internal readonly gl.glGetnCompressedTexImage glGetnCompressedTexImage;
internal readonly gl.glGetnTexImage glGetnTexImage;
internal readonly gl.glGetnUniformdv glGetnUniformdv;
internal readonly gl.glGetnUniformfv glGetnUniformfv;
internal readonly gl.glGetnUniformiv glGetnUniformiv;
internal readonly gl.glGetnUniformuiv glGetnUniformuiv;
internal readonly gl.glReadnPixels glReadnPixels;
internal readonly gl.glTextureBarrier glTextureBarrier;
internal readonly gl.glSpecializeShader glSpecializeShader;
internal readonly gl.glMultiDrawArraysIndirectCount glMultiDrawArraysIndirectCount;
internal readonly gl.glMultiDrawElementsIndirectCount glMultiDrawElementsIndirectCount;
internal readonly gl.glPolygonOffsetClamp glPolygonOffsetClamp;
}
}
+83
View File
@@ -0,0 +1,83 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace StgSharp.Graphics
{
/// <summary>
/// windows系统API类
/// </summary>
public partial class winapi
{
/// <summary>
/// The ChoosePixelFormat function attempts to match an appropriate pixel format supported by a device context to a given pixel format specification.
/// </summary>
/// <param name="hdc">
/// Specifies the device context that the function examines to determine the best match for the pixel format descriptor pointed to by ppfd.
/// </param>
/// <param name="ppfd">
/// Pointer to a PIXELFORMATDESCRIPTOR structure that specifies the requested pixel format.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a pixel format index (one-based) that is the closest match to the given pixel format descriptor.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
[DllImport("gdi32.dll", ExactSpelling = false, EntryPoint = "ChoosePixelFormat", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern int ChoosePixelFormat(IntPtr hdc, IntPtr ppfd);
/// <summary>
/// The SetPixelFormat function sets the pixel format of the specified device context to the format specified by the iPixelFormat index.
/// </summary>
/// <param name="hdc">
/// Specifies the device context whose pixel format the function attempts to set.</param>
/// <param name="format">
/// <para>Index that identifies the pixel format to set. </para>
/// <para>The various pixel formats supported by a device context are identified by one-based indexes.</para>
/// </param>
/// <param name="ppfd">
/// <para>Pointer to a PIXELFORMATDESCRIPTOR structure that contains the logical pixel format specification.</para>
/// <para>The system's metafile component uses this structure to record the logical pixel format specification.</para>
/// </param>
/// <returns>
/// If the function succeeds, the return value is TRUE.If the function fails, the return value is FALSE.
/// </returns>
[DllImport("gdi32.dll", ExactSpelling = false, EntryPoint = "SetPixelFormat", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern bool SetPixelFormat(IntPtr hdc, int format, IntPtr ppfd);
/// <summary>
/// <para>The GetDC function retrieves a handle to a device context (DC) for the client area of a specified window or for the entire screen.</para>
/// <para>You can use the returned handle in subsequent GDI functions to draw in the DC.</para>
/// </summary>
/// <param name="hwnd">
/// A handle to the window whose DC is to be retrieved. If this value is NULL, GetDC retrieves the DC for the entire screen.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the DC for the specified window's client area.</para>
/// <para>If the function fails, the return value is NULL.</para>
/// </returns>
[DllImport("user32.dll", ExactSpelling = false, EntryPoint = "GetDC", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr GetDC(IntPtr hwnd);
/// <summary>
/// The SwapBuffers function exchanges the front and back buffers if the current pixel format for the window referenced by the specified device context includes a back buffer.
/// </summary>
/// <param name="hdc">
/// <para>Specifies a device context.</para>
/// <para> If the current pixel format for the window referenced by this device context includes a back buffer,</para>
/// <para>the function exchanges the front and back buffers.</para>
/// </param>
/// <returns>
/// If the function succeeds, the return value is TRUE.If the function fails, the return value is FALSE.
/// </returns>
[DllImport("gdi32.dll", ExactSpelling = false, EntryPoint = "SwapBuffers", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern bool SwapBuffers(IntPtr hdc);
/// <summary>
/// 获取当前线程的控制台窗口句柄
/// </summary>
/// <returns>当前线程控制台句柄</returns>
[DllImport("kernel32.dll", ExactSpelling = false, EntryPoint = "GetConsoleWindow", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr GetConsoleWindow();
}
}
+4
View File
@@ -90,6 +90,10 @@ namespace StgSharp.Math
return new vec2d(vec.X/x, vec.Y/x);
}
public static implicit operator float[](vec2d vec)
{
return new float[2] {vec.X,vec.Y };
}
}
}
+18 -2
View File
@@ -1,4 +1,5 @@
using System;
using StgSharp.Optimization;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Runtime.InteropServices;
@@ -6,7 +7,7 @@ using System.Text;
namespace StgSharp.Math
{
[StructLayout(LayoutKind.Explicit)]
[StructLayout(LayoutKind.Explicit,Size =12,Pack =16)]
public struct vec3d : IEquatable<vec3d>
{
[FieldOffset(0)]
@@ -129,5 +130,20 @@ namespace StgSharp.Math
vec.Z / x
);
}
public static implicit operator float[](vec3d vec)
{
return new float[3] { vec.X, vec.Y, vec.Y };
}
public static implicit operator m128(vec3d vec)
{
return new m128()
{
float0 = vec.X,
float1 = vec.Y,
float2 = vec.Z,
};
}
}
}
+4 -1
View File
@@ -138,7 +138,10 @@ namespace StgSharp.Math
return new vec4d(vec.X / x, vec.Y / x, vec.Z / x, vec.W / x);
}
public static implicit operator float[](vec4d vec)
{
return new float[] { vec.X, vec.Y, vec.Z, vec.W };
}
}
+1 -14
View File
@@ -6,7 +6,6 @@ namespace StgSharp.Math
{
public static partial class Calc
{
private static m128 sqrtCache;
public static unsafe float Sqrt(float x)
{
@@ -21,7 +20,7 @@ namespace StgSharp.Math
if (x < 0)
{
throw new ArgumentOutOfRangeException();
throw new ArgumentOutOfRangeException("Input is smaller than zero!");
}
if (x == 0)
{
@@ -71,18 +70,6 @@ namespace StgSharp.Math
float result = *(float*)&e;
result = (result + x / result) / 2;
return (result + x / result) / 2;
/**/
/*
fixed (m128* p = &sqrtCache)
{
sqrtCache.float0 = x;
return (SSE.Sqrtss(p)).float0;
}
*/
}
[DllImport("xmmintrin.h",EntryPoint = "_mm_sqrt_ss")]
public static extern m128 Sqrtss(m128 a);
}
}
+63
View File
@@ -0,0 +1,63 @@
//------------------------------------------------------------------------------
// <auto-generated>
// 此代码由工具生成。
// 运行时版本:4.0.30319.42000
//
// 对此文件的更改可能会导致不正确的行为,并且如果
// 重新生成代码,这些更改将会丢失。
// </auto-generated>
//------------------------------------------------------------------------------
namespace StgSharp.Properties {
using System;
/// <summary>
/// 一个强类型的资源类,用于查找本地化的字符串等。
/// </summary>
// 此类是由 StronglyTypedResourceBuilder
// 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
// 若要添加或移除成员,请编辑 .ResX 文件,然后重新运行 ResGen
// (以 /str 作为命令选项),或重新生成 VS 项目。
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// 返回此类使用的缓存的 ResourceManager 实例。
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("StgSharp.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// 重写当前线程的 CurrentUICulture 属性,对
/// 使用此强类型资源类的所有资源查找执行重写。
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
}
}
@@ -0,0 +1,101 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 1.3
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">1.3</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1">this is my long string</data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
[base64 mime encoded serialized .NET Framework object]
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
[base64 mime encoded string representing a byte array form of the .NET Framework object]
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>1.3</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3500.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>
+31
View File
@@ -3,12 +3,15 @@
<PropertyGroup>
<TargetFramework>netstandard2.1</TargetFramework>
<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
<LangVersion>preview</LangVersion>
<ProduceReferenceAssembly>True</ProduceReferenceAssembly>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
<Platforms>AnyCPU;x64</Platforms>
<GeneratePackageOnBuild>False</GeneratePackageOnBuild>
<PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
<PackageLicenseExpression> MIT</PackageLicenseExpression>
<EnableNETAnalyzers>True</EnableNETAnalyzers>
<AnalysisLevel>preview-all</AnalysisLevel>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -17,6 +20,19 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Optimize>True</Optimize>
<DebugType>none</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>none</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>none</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<DebugType>none</DebugType>
</PropertyGroup>
<ItemGroup>
@@ -38,4 +54,19 @@
<Folder Include="Geometries\SpaceGeometry\" />
</ItemGroup>
<ItemGroup>
<Compile Update="Properties\Resources.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
</Project>
File diff suppressed because it is too large Load Diff
@@ -1,3 +1,11 @@
is_global = true
build_property.TargetFramework = netstandard2.1
build_property.TargetPlatformMinVersion = 7.0
build_property.UsingMicrosoftNETSdkWeb =
build_property.ProjectTypeGuids =
build_property.InvariantGlobalization =
build_property.PlatformNeutralAssembly =
build_property.EnforceExtendedAnalyzerRules =
build_property._SupportedPlatformList = Linux,macOS,Windows
build_property.RootNamespace = StgSharp
build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\
@@ -1 +1 @@
33fb0045551e4bbd356407967287757930f40053
012b41110739971f732c5a1d8cfcd68b277b1396
@@ -1,6 +1,5 @@
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\bin\x64\Debug\netstandard2.1\StgSharp.deps.json
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\bin\x64\Debug\netstandard2.1\StgSharp.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\bin\x64\Debug\netstandard2.1\StgSharp.pdb
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\bin\x64\Debug\netstandard2.1\StgSharp.xml
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.csproj.AssemblyReference.cache
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.GeneratedMSBuildEditorConfig.editorconfig
@@ -10,5 +9,6 @@ D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\refint\StgSharp.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.xml
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.pdb
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\ref\StgSharp.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.Properties.Resources.resources
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp\obj\x64\Debug\netstandard2.1\StgSharp.csproj.GenerateResource.cache
File diff suppressed because it is too large Load Diff
+4 -5
View File
@@ -10,7 +10,8 @@ internal class Program
{
private unsafe static void Main(string[] args)
{
/**/
#if DEBUG
double time;
TimeSpan span;
m128 m = new m128();
@@ -33,7 +34,7 @@ internal class Program
stopwatch02.Start();
for (int t = 0; t < 1000000; t++)
{
mf = Calc.Sqrt(t);
mf = Calc.Sqrts(t);
}
stopwatch02.Stop();
span = stopwatch02.Elapsed;
@@ -42,9 +43,7 @@ internal class Program
Console.WriteLine();
}
/**/
#endif
}
}
File diff suppressed because it is too large Load Diff
@@ -4,7 +4,6 @@ D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharp
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\bin\x64\Debug\net6.0\StgSharpDebug.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\bin\x64\Debug\net6.0\StgSharpDebug.pdb
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\bin\x64\Debug\net6.0\StgSharp.dll
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\bin\x64\Debug\net6.0\StgSharp.pdb
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\bin\x64\Debug\net6.0\StgSharp.xml
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\obj\x64\Debug\net6.0\StgSharpDebug.csproj.AssemblyReference.cache
D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\obj\x64\Debug\net6.0\StgSharpDebug.GeneratedMSBuildEditorConfig.editorconfig
View File