youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1c9b820531e7502a071d775d1094201ed5389f66
stgsharp/StgSharp.Common/Graphics/OpenGL/glApiManager.cs
T
Youmu Liu 1927f4fdf3 code clean up
2025-10-17 10:49:00 +08:00

4973 lines
225 KiB
C#
Raw Blame History

//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="glApiManager"
// Project: StgSharp
// AuthorGroup: Nitload
// Copyright (c) Nitload. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using StgSharp.HighPerformance;
using StgSharp.Mathematics;
using StgSharp.MVVM;
using StgSharp.MVVM;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Graphics.OpenGL
{
public static partial class glManager
{
private const int glExtension = 0x1f03;
private const int glVersion = 0x1f02;
private static readonly string[] glBranch = {
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
"OpenGL SC "
};
private static string glExtensionList;
// --------------------------------------------------------------------------------
/// <summary>
/// Get the function pointer of given OpenGL api _label
/// </summary>
/// <param _label="name">
/// ContextName of the OpenGL api
/// </param>
/// <returns>
/// The funtion pointer of the api in stream of <see cref="IntPtr" />
/// </returns>
public static IntPtr LoadGLfunc(string name)
{
IntPtr ret = InternalIO.glfwGetProcAddress(Encoding.UTF8.GetBytes(name));
if (ret == default)
{
InternalIO.InternalAppendLog(
$"Cannot load OpenGL api called {name}, this api may not exist or supported.");
return ret;
}
return ret;
}
/// <summary>
/// Load all supported OpenGL APIs and bind them to given <see cref="ViewPort" />.
/// </summary>
/// <param _label="contextHandle">
/// The handle to current OpenGL viewPortDisplay
/// </param>
public static unsafe void LoadOpenGLApiTo(IntPtr contextHandle)
{
OpenglContext* context = (OpenglContext*)contextHandle;
if ((IntPtr)context->glGetString != IntPtr.Zero) {
return;
}
delegate*<string, IntPtr> loader = &InternalIO.glfwGetProcAddress;
IntPtr proc = InternalIO.glfwGetProcAddress("glGetString");
if (proc == IntPtr.Zero)
{
#if DEBUG
Console.WriteLine("Cannot load GL.");
#endif
throw new Exception("Cannot load gl");
}
context->glGetString = (delegate*<uint, IntPtr>)proc;
string coreVersion;
if (context->glGetString(glVersion) == IntPtr.Zero) {
InternalIO.InternalWriteLog("Failed to call glGetString", LogType.Error);
}
coreVersion = Marshal.PtrToStringAnsi(context->glGetString(glVersion)) ?? string.Empty;
foreach (string branch in glBranch)
{
if (coreVersion.Contains(branch)) {
coreVersion.Replace(branch, string.Empty);
}
}
string[] versionSep = coreVersion!.Split('.');
int majorVersion = int.Parse(versionSep[0]);
int minorVersion = int.Parse(versionSep[1]);
CheckCoreVersion(majorVersion, minorVersion);
try
{
#region load_core_gl
LoadGLcore10(context, loader);
LoadGLcore11(context, loader);
LoadGLcore12(context, loader);
LoadGLcore13(context, loader);
LoadGLcore14(context, loader);
LoadGLcore15(context, loader);
LoadGLcore20(context, loader);
LoadGLcore21(context, loader);
LoadGLcore30(context, loader);
LoadGLcore31(context, loader);
LoadGLcore32(context, loader);
LoadGLcore33(context, loader);
LoadGLcore40(context, loader);
LoadGLcore41(context, loader);
LoadGLcore42(context, loader);
LoadGLcore43(context, loader);
LoadGLcore44(context, loader);
LoadGLcore45(context, loader);
LoadGLcore46(context, loader);
#endregion load_core_gl
}
catch (Exception ex)
{
if (ex.Message != "Final Version") {
throw;
}
}
uint code = context->glGetError();
if (code != 0)
{
Console.WriteLine(code);
throw new GlExecutionException(code);
}
int extensionCount;
context->glGetIntegerv(glConst.NUM_EXTENSIONS, &extensionCount);
if (extensionCount == 0)
{
InternalIO.InternalWriteLog(
"No supported OpenGL extensions are found.", LogType.Info);
return;
}
HashSet<string> extensions = [];
for (uint i = 0; i < extensionCount; i++)
{
byte* strPtr = context->glGetStringi(glConst.EXTENSIONS, i);
extensions.Add(Marshal.PtrToStringAnsi((IntPtr)strPtr) ?? string.Empty);
}
InternalIO.InternalWriteLog(
$"{$"Find OpenGL extensions:"}{Environment.NewLine}{string.Join(';', extensions)}",
LogType.Info);
#region checkGLextensions
if (extensions.Contains("gl_4DFX_multisample"))
{
_4DFX_multisample = true;
extensions.Remove("gl_4DFX_multisample");
}
if (extensions.Contains("gl_3DFX_tbuffer"))
{
_3DFX_tbuffer = true;
extensions.Remove("gl_3DFX_tbuffer");
}
if (extensions.Contains("gl_3DFX_texture_compression_FXT1"))
{
_3DFX_texture_compression_FXT1 = true;
extensions.Remove("gl_3DFX_texture_compression_FXT1");
}
if (extensions.Contains("gl_AMD_blend_minmax_factor"))
{
AMD_blend_minmax_factor = true;
extensions.Remove("glAMD_blend_minmax_factor");
}
if (extensions.Contains("gl_AMD_conservative_depth"))
{
AMD_conservative_depth = true;
extensions.Remove("glAMD_conservative_depth");
}
if (extensions.Contains("gl_AMD_debug_output"))
{
AMD_debug_output = true;
extensions.Remove("glAMD_debug_output");
}
if (extensions.Contains("gl_AMD_depth_clamp_separate"))
{
AMD_depth_clamp_separate = true;
extensions.Remove("glAMD_depth_clamp_separate");
}
if (extensions.Contains("gl_AMD_draw_buffers_blend"))
{
AMD_draw_buffers_blend = true;
extensions.Remove("glAMD_draw_buffers_blend");
}
if (extensions.Contains("gl_AMD_framebuffer_multisample_advanced"))
{
AMD_framebuffer_multisample_advanced = true;
extensions.Remove("glAMD_framebuffer_multisample_advanced");
}
if (extensions.Contains("gl_AMD_framebuffer_sample_positions"))
{
AMD_framebuffer_sample_positions = true;
extensions.Remove("glAMD_framebuffer_sample_positions");
}
if (extensions.Contains("gl_AMD_gcn_shader"))
{
AMD_gcn_shader = true;
extensions.Remove("glAMD_gcn_shader");
}
if (extensions.Contains("gl_AMD_gpu_shader_half_float"))
{
AMD_gpu_shader_half_float = true;
extensions.Remove("glAMD_gpu_shader_half_float");
}
if (extensions.Contains("gl_AMD_gpu_shader_int16"))
{
AMD_gpu_shader_int16 = true;
extensions.Remove("glAMD_gpu_shader_int16");
}
if (extensions.Contains("gl_AMD_gpu_shader_int64"))
{
AMD_gpu_shader_int64 = true;
extensions.Remove("glAMD_gpu_shader_int64");
}
if (extensions.Contains("gl_AMD_interleaved_elements"))
{
AMD_interleaved_elements = true;
extensions.Remove("glAMD_interleaved_elements");
}
if (extensions.Contains("gl_AMD_multi_draw_indirect"))
{
AMD_multi_draw_indirect = true;
extensions.Remove("glAMD_multi_draw_indirect");
}
if (extensions.Contains("gl_AMD_name_gen_delete"))
{
AMD_name_gen_delete = true;
extensions.Remove("glAMD_name_gen_delete");
}
if (extensions.Contains("gl_AMD_occlusion_query_event"))
{
AMD_occlusion_query_event = true;
extensions.Remove("glAMD_occlusion_query_event");
}
if (extensions.Contains("gl_AMD_performance_monitor"))
{
AMD_performance_monitor = true;
extensions.Remove("glAMD_performance_monitor");
}
if (extensions.Contains("gl_AMD_pinned_memory"))
{
AMD_pinned_memory = true;
extensions.Remove("glAMD_pinned_memory");
}
if (extensions.Contains("gl_AMD_query_buffer_object"))
{
AMD_query_buffer_object = true;
extensions.Remove("glAMD_query_buffer_object");
}
if (extensions.Contains("gl_AMD_sample_positions"))
{
AMD_sample_positions = true;
extensions.Remove("glAMD_sample_positions");
}
if (extensions.Contains("gl_AMD_seamless_cubemap_per_texture"))
{
AMD_seamless_cubemap_per_texture = true;
extensions.Remove("glAMD_seamless_cubemap_per_texture");
}
if (extensions.Contains("gl_AMD_shader_atomic_counter_ops"))
{
AMD_shader_atomic_counter_ops = true;
extensions.Remove("glAMD_shader_atomic_counter_ops");
}
if (extensions.Contains("gl_AMD_shader_ballot"))
{
AMD_shader_ballot = true;
extensions.Remove("glAMD_shader_ballot");
}
if (extensions.Contains("gl_AMD_shader_explicit_vertex_parameter"))
{
AMD_shader_explicit_vertex_parameter = true;
extensions.Remove("glAMD_shader_explicit_vertex_parameter");
}
if (extensions.Contains("gl_AMD_shader_gpu_shader_half_float_fetch"))
{
AMD_shader_gpu_shader_half_float_fetch = true;
extensions.Remove("glAMD_shader_gpu_shader_half_float_fetch");
}
if (extensions.Contains("gl_AMD_shader_image_load_store_lod"))
{
AMD_shader_image_load_store_lod = true;
extensions.Remove("glAMD_shader_image_load_store_lod");
}
if (extensions.Contains("gl_AMD_shader_stencil_export"))
{
AMD_shader_stencil_export = true;
extensions.Remove("glAMD_shader_stencil_export");
}
if (extensions.Contains("gl_AMD_shader_trinary_minmax"))
{
AMD_shader_trinary_minmax = true;
extensions.Remove("glAMD_shader_trinary_minmax");
}
if (extensions.Contains("gl_AMD_sparse_texture"))
{
AMD_sparse_texture = true;
extensions.Remove("glAMD_sparse_texture");
}
if (extensions.Contains("gl_AMD_stencil_operation_extended"))
{
AMD_stencil_operation_extended = true;
extensions.Remove("glAMD_stencil_operation_extended");
}
if (extensions.Contains("gl_AMD_texture_gather_bias_lod"))
{
AMD_texture_gather_bias_lod = true;
extensions.Remove("glAMD_texture_gather_bias_lod");
}
if (extensions.Contains("gl_AMD_texture_texture4"))
{
AMD_texture_texture4 = true;
extensions.Remove("glAMD_texture_texture4");
}
if (extensions.Contains("gl_AMD_transform_feedback3_lines_triangles"))
{
AMD_transform_feedback3_lines_triangles = true;
extensions.Remove("glAMD_transform_feedback3_lines_triangles");
}
if (extensions.Contains("gl_AMD_transform_feedback4"))
{
AMD_transform_feedback4 = true;
extensions.Remove("glAMD_transform_feedback4");
}
if (extensions.Contains("gl_AMD_vertex_shader_layer"))
{
AMD_vertex_shader_layer = true;
extensions.Remove("glAMD_vertex_shader_layer");
}
if (extensions.Contains("gl_AMD_vertex_shader_tessellator"))
{
AMD_vertex_shader_tessellator = true;
extensions.Remove("glAMD_vertex_shader_tessellator");
}
if (extensions.Contains("gl_AMD_vertex_shader_viewport_index"))
{
AMD_vertex_shader_viewport_index = true;
extensions.Remove("glAMD_vertex_shader_viewport_index");
}
if (extensions.Contains("gl_APPLE_aux_depth_stencil"))
{
APPLE_aux_depth_stencil = true;
extensions.Remove("glAPPLE_aux_depth_stencil");
}
if (extensions.Contains("gl_APPLE_client_storage"))
{
APPLE_client_storage = true;
extensions.Remove("glAPPLE_client_storage");
}
if (extensions.Contains("gl_APPLE_element_array"))
{
APPLE_element_array = true;
extensions.Remove("glAPPLE_element_array");
}
if (extensions.Contains("gl_APPLE_fence"))
{
APPLE_fence = true;
extensions.Remove("glAPPLE_fence");
}
if (extensions.Contains("gl_APPLE_float_pixels"))
{
APPLE_float_pixels = true;
extensions.Remove("glAPPLE_float_pixels");
}
if (extensions.Contains("gl_APPLE_flush_buffer_range"))
{
APPLE_flush_buffer_range = true;
extensions.Remove("glAPPLE_flush_buffer_range");
}
if (extensions.Contains("gl_APPLE_object_purgeable"))
{
APPLE_object_purgeable = true;
extensions.Remove("glAPPLE_object_purgeable");
}
if (extensions.Contains("gl_APPLE_rgb_422"))
{
APPLE_rgb_422 = true;
extensions.Remove("glAPPLE_rgb_422");
}
if (extensions.Contains("gl_APPLE_row_bytes"))
{
APPLE_row_bytes = true;
extensions.Remove("glAPPLE_row_bytes");
}
if (extensions.Contains("gl_APPLE_specular_vector"))
{
APPLE_specular_vector = true;
extensions.Remove("glAPPLE_specular_vector");
}
if (extensions.Contains("gl_APPLE_texture_range"))
{
APPLE_texture_range = true;
extensions.Remove("glAPPLE_texture_range");
}
if (extensions.Contains("gl_APPLE_transform_hint"))
{
APPLE_transform_hint = true;
extensions.Remove("glAPPLE_transform_hint");
}
if (extensions.Contains("gl_APPLE_vertex_array_object"))
{
APPLE_vertex_array_object = true;
extensions.Remove("glAPPLE_vertex_array_object");
}
if (extensions.Contains("gl_APPLE_vertex_array_range"))
{
APPLE_vertex_array_range = true;
extensions.Remove("glAPPLE_vertex_array_range");
}
if (extensions.Contains("gl_APPLE_vertex_program_evaluators"))
{
APPLE_vertex_program_evaluators = true;
extensions.Remove("glAPPLE_vertex_program_evaluators");
}
if (extensions.Contains("gl_APPLE_ycbcr_422"))
{
APPLE_ycbcr_422 = true;
extensions.Remove("glAPPLE_ycbcr_422");
}
if (extensions.Contains("gl_ARB_ES2_compatibility"))
{
ARB_ES2_compatibility = true;
extensions.Remove("glARB_ES2_compatibility");
}
if (extensions.Contains("gl_ARB_ES3_1_compatibility"))
{
ARB_ES3_1_compatibility = true;
extensions.Remove("glARB_ES3_1_compatibility");
}
if (extensions.Contains("gl_ARB_ES3_2_compatibility"))
{
ARB_ES3_2_compatibility = true;
extensions.Remove("glARB_ES3_2_compatibility");
}
if (extensions.Contains("gl_ARB_ES3_compatibility"))
{
ARB_ES3_compatibility = true;
extensions.Remove("glARB_ES3_compatibility");
}
if (extensions.Contains("gl_ARB_arrays_of_arrays"))
{
ARB_arrays_of_arrays = true;
extensions.Remove("glARB_arrays_of_arrays");
}
if (extensions.Contains("gl_ARB_base_instance"))
{
ARB_base_instance = true;
extensions.Remove("glARB_base_instance");
}
if (extensions.Contains("gl_ARB_bindless_texture"))
{
ARB_bindless_texture = true;
extensions.Remove("glARB_bindless_texture");
}
if (extensions.Contains("gl_ARB_blend_func_extended"))
{
ARB_blend_func_extended = true;
extensions.Remove("glARB_blend_func_extended");
}
if (extensions.Contains("gl_ARB_buffer_storage"))
{
ARB_buffer_storage = true;
extensions.Remove("glARB_buffer_storage");
}
if (extensions.Contains("gl_ARB_cl_event"))
{
ARB_cl_event = true;
extensions.Remove("glARB_cl_event");
}
if (extensions.Contains("gl_ARB_clear_buffer_object"))
{
ARB_clear_buffer_object = true;
extensions.Remove("glARB_clear_buffer_object");
}
if (extensions.Contains("gl_ARB_clear_texture"))
{
ARB_clear_texture = true;
extensions.Remove("glARB_clear_texture");
}
if (extensions.Contains("gl_ARB_clip_control"))
{
ARB_clip_control = true;
extensions.Remove("glARB_clip_control");
}
if (extensions.Contains("gl_ARB_color_buffer_float"))
{
ARB_color_buffer_float = true;
extensions.Remove("glARB_color_buffer_float");
}
if (extensions.Contains("gl_ARB_compatibility"))
{
ARB_compatibility = true;
extensions.Remove("glARB_compatibility");
}
if (extensions.Contains("gl_ARB_compressed_texture_pixel_storage"))
{
ARB_compressed_texture_pixel_storage = true;
extensions.Remove("glARB_compressed_texture_pixel_storage");
}
if (extensions.Contains("gl_ARB_compute_shader"))
{
ARB_compute_shader = true;
extensions.Remove("glARB_compute_shader");
}
if (extensions.Contains("gl_ARB_compute_variable_group_size"))
{
ARB_compute_variable_group_size = true;
extensions.Remove("glARB_compute_variable_group_size");
}
if (extensions.Contains("gl_ARB_conditional_render_inverted"))
{
ARB_conditional_render_inverted = true;
extensions.Remove("glARB_conditional_render_inverted");
}
if (extensions.Contains("gl_ARB_conservative_depth"))
{
ARB_conservative_depth = true;
extensions.Remove("glARB_conservative_depth");
}
if (extensions.Contains("gl_ARB_copy_buffer"))
{
ARB_copy_buffer = true;
extensions.Remove("glARB_copy_buffer");
}
if (extensions.Contains("gl_ARB_copy_image"))
{
ARB_copy_image = true;
extensions.Remove("glARB_copy_image");
}
if (extensions.Contains("gl_ARB_cull_distance"))
{
ARB_cull_distance = true;
extensions.Remove("glARB_cull_distance");
}
if (extensions.Contains("gl_ARB_debug_output"))
{
ARB_debug_output = true;
extensions.Remove("glARB_debug_output");
}
if (extensions.Contains("gl_ARB_depth_buffer_float"))
{
ARB_depth_buffer_float = true;
extensions.Remove("glARB_depth_buffer_float");
}
if (extensions.Contains("gl_ARB_depth_clamp"))
{
ARB_depth_clamp = true;
extensions.Remove("glARB_depth_clamp");
}
if (extensions.Contains("gl_ARB_depth_texture"))
{
ARB_depth_texture = true;
extensions.Remove("glARB_depth_texture");
}
if (extensions.Contains("gl_ARB_derivative_control"))
{
ARB_derivative_control = true;
extensions.Remove("glARB_derivative_control");
}
if (extensions.Contains("gl_ARB_direct_state_access"))
{
ARB_direct_state_access = true;
extensions.Remove("glARB_direct_state_access");
}
if (extensions.Contains("gl_ARB_draw_buffers"))
{
ARB_draw_buffers = true;
extensions.Remove("glARB_draw_buffers");
}
if (extensions.Contains("gl_ARB_draw_buffers_blend"))
{
ARB_draw_buffers_blend = true;
extensions.Remove("glARB_draw_buffers_blend");
}
if (extensions.Contains("gl_ARB_draw_elements_base_vertex"))
{
ARB_draw_elements_base_vertex = true;
extensions.Remove("glARB_draw_elements_base_vertex");
}
if (extensions.Contains("gl_ARB_draw_indirect"))
{
ARB_draw_indirect = true;
extensions.Remove("glARB_draw_indirect");
}
if (extensions.Contains("gl_ARB_draw_instanced"))
{
ARB_draw_instanced = true;
extensions.Remove("glARB_draw_instanced");
}
if (extensions.Contains("gl_ARB_enhanced_layouts"))
{
ARB_enhanced_layouts = true;
extensions.Remove("glARB_enhanced_layouts");
}
if (extensions.Contains("gl_ARB_explicit_attrib_location"))
{
ARB_explicit_attrib_location = true;
extensions.Remove("glARB_explicit_attrib_location");
}
if (extensions.Contains("gl_ARB_explicit_uniform_location"))
{
ARB_explicit_uniform_location = true;
extensions.Remove("glARB_explicit_uniform_location");
}
if (extensions.Contains("gl_ARB_fragment_coord_conventions"))
{
ARB_fragment_coord_conventions = true;
extensions.Remove("glARB_fragment_coord_conventions");
}
if (extensions.Contains("gl_ARB_fragment_layer_viewport"))
{
ARB_fragment_layer_viewport = true;
extensions.Remove("glARB_fragment_layer_viewport");
}
if (extensions.Contains("gl_ARB_fragment_program"))
{
ARB_fragment_program = true;
extensions.Remove("glARB_fragment_program");
}
if (extensions.Contains("gl_ARB_fragment_program_shadow"))
{
ARB_fragment_program_shadow = true;
extensions.Remove("glARB_fragment_program_shadow");
}
if (extensions.Contains("gl_ARB_fragment_shader"))
{
ARB_fragment_shader = true;
extensions.Remove("glARB_fragment_shader");
}
if (extensions.Contains("gl_ARB_fragment_shader_interlock"))
{
ARB_fragment_shader_interlock = true;
extensions.Remove("glARB_fragment_shader_interlock");
}
if (extensions.Contains("gl_ARB_framebuffer_no_attachments"))
{
ARB_framebuffer_no_attachments = true;
extensions.Remove("glARB_framebuffer_no_attachments");
}
if (extensions.Contains("gl_ARB_framebuffer_object"))
{
ARB_framebuffer_object = true;
extensions.Remove("glARB_framebuffer_object");
}
if (extensions.Contains("gl_ARB_framebuffer_sRGB"))
{
ARB_framebuffer_sRGB = true;
extensions.Remove("glARB_framebuffer_sRGB");
}
if (extensions.Contains("gl_ARB_geometry_shader4"))
{
ARB_geometry_shader4 = true;
extensions.Remove("glARB_geometry_shader4");
}
if (extensions.Contains("gl_ARB_get_program_binary"))
{
ARB_get_program_binary = true;
extensions.Remove("glARB_get_program_binary");
}
if (extensions.Contains("gl_ARB_get_texture_sub_image"))
{
ARB_get_texture_sub_image = true;
extensions.Remove("glARB_get_texture_sub_image");
}
if (extensions.Contains("gl_ARB_gl_spirv"))
{
ARB_gl_spirv = true;
extensions.Remove("glARB_gl_spirv");
}
if (extensions.Contains("gl_ARB_gpu_shader5"))
{
ARB_gpu_shader5 = true;
extensions.Remove("glARB_gpu_shader5");
}
if (extensions.Contains("gl_ARB_gpu_shader_fp64"))
{
ARB_gpu_shader_fp64 = true;
extensions.Remove("glARB_gpu_shader_fp64");
}
if (extensions.Contains("gl_ARB_gpu_shader_int64"))
{
ARB_gpu_shader_int64 = true;
extensions.Remove("glARB_gpu_shader_int64");
}
if (extensions.Contains("gl_ARB_half_float_pixel"))
{
ARB_half_float_pixel = true;
extensions.Remove("glARB_half_float_pixel");
}
if (extensions.Contains("gl_ARB_half_float_vertex"))
{
ARB_half_float_vertex = true;
extensions.Remove("glARB_half_float_vertex");
}
if (extensions.Contains("gl_ARB_imaging"))
{
ARB_imaging = true;
extensions.Remove("glARB_imaging");
}
if (extensions.Contains("gl_ARB_indirect_parameters"))
{
ARB_indirect_parameters = true;
extensions.Remove("glARB_indirect_parameters");
}
if (extensions.Contains("gl_ARB_instanced_arrays"))
{
ARB_instanced_arrays = true;
extensions.Remove("glARB_instanced_arrays");
}
if (extensions.Contains("gl_ARB_internalformat_query"))
{
ARB_internalformat_query = true;
extensions.Remove("glARB_internalformat_query");
}
if (extensions.Contains("gl_ARB_internalformat_query2"))
{
ARB_internalformat_query2 = true;
extensions.Remove("glARB_internalformat_query2");
}
if (extensions.Contains("gl_ARB_invalidate_subdata"))
{
ARB_invalidate_subdata = true;
extensions.Remove("glARB_invalidate_subdata");
}
if (extensions.Contains("gl_ARB_map_buffer_alignment"))
{
ARB_map_buffer_alignment = true;
extensions.Remove("glARB_map_buffer_alignment");
}
if (extensions.Contains("gl_ARB_map_buffer_range"))
{
ARB_map_buffer_range = true;
extensions.Remove("glARB_map_buffer_range");
}
if (extensions.Contains("gl_ARB_matrix_palette"))
{
ARB_matrix_palette = true;
extensions.Remove("glARB_matrix_palette");
}
if (extensions.Contains("gl_ARB_multi_bind"))
{
ARB_multi_bind = true;
extensions.Remove("glARB_multi_bind");
}
if (extensions.Contains("gl_ARB_multi_draw_indirect"))
{
ARB_multi_draw_indirect = true;
extensions.Remove("glARB_multi_draw_indirect");
}
if (extensions.Contains("gl_ARB_multisample"))
{
ARB_multisample = true;
extensions.Remove("glARB_multisample");
}
if (extensions.Contains("gl_ARB_multitexture"))
{
ARB_multitexture = true;
extensions.Remove("glARB_multitexture");
}
if (extensions.Contains("gl_ARB_occlusion_query"))
{
ARB_occlusion_query = true;
extensions.Remove("glARB_occlusion_query");
}
if (extensions.Contains("gl_ARB_occlusion_query2"))
{
ARB_occlusion_query2 = true;
extensions.Remove("glARB_occlusion_query2");
}
if (extensions.Contains("gl_ARB_parallel_shader_compile"))
{
ARB_parallel_shader_compile = true;
extensions.Remove("glARB_parallel_shader_compile");
}
if (extensions.Contains("gl_ARB_pipeline_statistics_query"))
{
ARB_pipeline_statistics_query = true;
extensions.Remove("glARB_pipeline_statistics_query");
}
if (extensions.Contains("gl_ARB_pixel_buffer_object"))
{
ARB_pixel_buffer_object = true;
extensions.Remove("glARB_pixel_buffer_object");
}
if (extensions.Contains("gl_ARB_point_parameters"))
{
ARB_point_parameters = true;
extensions.Remove("glARB_point_parameters");
}
if (extensions.Contains("gl_ARB_point_sprite"))
{
ARB_point_sprite = true;
extensions.Remove("glARB_point_sprite");
}
if (extensions.Contains("gl_ARB_polygon_offset_clamp"))
{
ARB_polygon_offset_clamp = true;
extensions.Remove("glARB_polygon_offset_clamp");
}
if (extensions.Contains("gl_ARB_post_depth_coverage"))
{
ARB_post_depth_coverage = true;
extensions.Remove("glARB_post_depth_coverage");
}
if (extensions.Contains("gl_ARB_program_interface_query"))
{
ARB_program_interface_query = true;
extensions.Remove("glARB_program_interface_query");
}
if (extensions.Contains("gl_ARB_provoking_vertex"))
{
ARB_provoking_vertex = true;
extensions.Remove("glARB_provoking_vertex");
}
if (extensions.Contains("gl_ARB_query_buffer_object"))
{
ARB_query_buffer_object = true;
extensions.Remove("glARB_query_buffer_object");
}
if (extensions.Contains("gl_ARB_robust_buffer_access_behavior"))
{
ARB_robust_buffer_access_behavior = true;
extensions.Remove("glARB_robust_buffer_access_behavior");
}
if (extensions.Contains("gl_ARB_robustness"))
{
ARB_robustness = true;
extensions.Remove("glARB_robustness");
}
if (extensions.Contains("gl_ARB_robustness_isolation"))
{
ARB_robustness_isolation = true;
extensions.Remove("glARB_robustness_isolation");
}
if (extensions.Contains("gl_ARB_sample_locations"))
{
ARB_sample_locations = true;
extensions.Remove("glARB_sample_locations");
}
if (extensions.Contains("gl_ARB_sample_shading"))
{
ARB_sample_shading = true;
extensions.Remove("glARB_sample_shading");
}
if (extensions.Contains("gl_ARB_sampler_objects"))
{
ARB_sampler_objects = true;
extensions.Remove("glARB_sampler_objects");
}
if (extensions.Contains("gl_ARB_seamless_cube_map"))
{
ARB_seamless_cube_map = true;
extensions.Remove("glARB_seamless_cube_map");
}
if (extensions.Contains("gl_ARB_seamless_cubemap_per_texture"))
{
ARB_seamless_cubemap_per_texture = true;
extensions.Remove("glARB_seamless_cubemap_per_texture");
}
if (extensions.Contains("gl_ARB_separate_shader_objects"))
{
ARB_separate_shader_objects = true;
extensions.Remove("glARB_separate_shader_objects");
}
if (extensions.Contains("gl_ARB_shader_atomic_counter_ops"))
{
ARB_shader_atomic_counter_ops = true;
extensions.Remove("glARB_shader_atomic_counter_ops");
}
if (extensions.Contains("gl_ARB_shader_atomic_counters"))
{
ARB_shader_atomic_counters = true;
extensions.Remove("glARB_shader_atomic_counters");
}
if (extensions.Contains("gl_ARB_shader_ballot"))
{
ARB_shader_ballot = true;
extensions.Remove("glARB_shader_ballot");
}
if (extensions.Contains("gl_ARB_shader_bit_encoding"))
{
ARB_shader_bit_encoding = true;
extensions.Remove("glARB_shader_bit_encoding");
}
if (extensions.Contains("gl_ARB_shader_clock"))
{
ARB_shader_clock = true;
extensions.Remove("glARB_shader_clock");
}
if (extensions.Contains("gl_ARB_shader_draw_parameters"))
{
ARB_shader_draw_parameters = true;
extensions.Remove("glARB_shader_draw_parameters");
}
if (extensions.Contains("gl_ARB_shader_group_vote"))
{
ARB_shader_group_vote = true;
extensions.Remove("glARB_shader_group_vote");
}
if (extensions.Contains("gl_ARB_shader_image_load_store"))
{
ARB_shader_image_load_store = true;
extensions.Remove("glARB_shader_image_load_store");
}
if (extensions.Contains("gl_ARB_shader_image_size"))
{
ARB_shader_image_size = true;
extensions.Remove("glARB_shader_image_size");
}
if (extensions.Contains("gl_ARB_shader_objects"))
{
ARB_shader_objects = true;
extensions.Remove("glARB_shader_objects");
}
if (extensions.Contains("gl_ARB_shader_precision"))
{
ARB_shader_precision = true;
extensions.Remove("glARB_shader_precision");
}
if (extensions.Contains("gl_ARB_shader_stencil_export"))
{
ARB_shader_stencil_export = true;
extensions.Remove("glARB_shader_stencil_export");
}
if (extensions.Contains("gl_ARB_shader_storage_buffer_object"))
{
ARB_shader_storage_buffer_object = true;
extensions.Remove("glARB_shader_storage_buffer_object");
}
if (extensions.Contains("gl_ARB_shader_subroutine"))
{
ARB_shader_subroutine = true;
extensions.Remove("glARB_shader_subroutine");
}
if (extensions.Contains("gl_ARB_shader_texture_image_samples"))
{
ARB_shader_texture_image_samples = true;
extensions.Remove("glARB_shader_texture_image_samples");
}
if (extensions.Contains("gl_ARB_shader_texture_lod"))
{
ARB_shader_texture_lod = true;
extensions.Remove("glARB_shader_texture_lod");
}
if (extensions.Contains("gl_ARB_shader_viewport_layer_array"))
{
ARB_shader_viewport_layer_array = true;
extensions.Remove("glARB_shader_viewport_layer_array");
}
if (extensions.Contains("gl_ARB_shading_language_100"))
{
ARB_shading_language_100 = true;
extensions.Remove("glARB_shading_language_100");
}
if (extensions.Contains("gl_ARB_shading_language_420pack"))
{
ARB_shading_language_420pack = true;
extensions.Remove("glARB_shading_language_420pack");
}
if (extensions.Contains("gl_ARB_shading_language_include"))
{
ARB_shading_language_include = true;
extensions.Remove("glARB_shading_language_include");
}
if (extensions.Contains("gl_ARB_shading_language_packing"))
{
ARB_shading_language_packing = true;
extensions.Remove("glARB_shading_language_packing");
}
if (extensions.Contains("gl_ARB_shadow"))
{
ARB_shadow = true;
extensions.Remove("glARB_shadow");
}
if (extensions.Contains("gl_ARB_shadow_ambient"))
{
ARB_shadow_ambient = true;
extensions.Remove("glARB_shadow_ambient");
}
if (extensions.Contains("gl_ARB_sparse_buffer"))
{
ARB_sparse_buffer = true;
extensions.Remove("glARB_sparse_buffer");
}
if (extensions.Contains("gl_ARB_sparse_texture"))
{
ARB_sparse_texture = true;
extensions.Remove("glARB_sparse_texture");
}
if (extensions.Contains("gl_ARB_sparse_texture2"))
{
ARB_sparse_texture2 = true;
extensions.Remove("glARB_sparse_texture2");
}
if (extensions.Contains("gl_ARB_sparse_texture_clamp"))
{
ARB_sparse_texture_clamp = true;
extensions.Remove("glARB_sparse_texture_clamp");
}
if (extensions.Contains("gl_ARB_spirv_extensions"))
{
ARB_spirv_extensions = true;
extensions.Remove("glARB_spirv_extensions");
}
if (extensions.Contains("gl_ARB_stencil_texturing"))
{
ARB_stencil_texturing = true;
extensions.Remove("glARB_stencil_texturing");
}
if (extensions.Contains("gl_ARB_sync"))
{
ARB_sync = true;
extensions.Remove("glARB_sync");
}
if (extensions.Contains("gl_ARB_tessellation_shader"))
{
ARB_tessellation_shader = true;
extensions.Remove("glARB_tessellation_shader");
}
if (extensions.Contains("gl_ARB_texture_barrier"))
{
ARB_texture_barrier = true;
extensions.Remove("glARB_texture_barrier");
}
if (extensions.Contains("gl_ARB_texture_border_clamp"))
{
ARB_texture_border_clamp = true;
extensions.Remove("glARB_texture_border_clamp");
}
if (extensions.Contains("gl_ARB_texture_buffer_object"))
{
ARB_texture_buffer_object = true;
extensions.Remove("glARB_texture_buffer_object");
}
if (extensions.Contains("gl_ARB_texture_buffer_object_rgb32"))
{
ARB_texture_buffer_object_rgb32 = true;
extensions.Remove("glARB_texture_buffer_object_rgb32");
}
if (extensions.Contains("gl_ARB_texture_buffer_range"))
{
ARB_texture_buffer_range = true;
extensions.Remove("glARB_texture_buffer_range");
}
if (extensions.Contains("gl_ARB_texture_compression"))
{
ARB_texture_compression = true;
extensions.Remove("glARB_texture_compression");
}
if (extensions.Contains("gl_ARB_texture_compression_bptc"))
{
ARB_texture_compression_bptc = true;
extensions.Remove("glARB_texture_compression_bptc");
}
if (extensions.Contains("gl_ARB_texture_compression_rgtc"))
{
ARB_texture_compression_rgtc = true;
extensions.Remove("glARB_texture_compression_rgtc");
}
if (extensions.Contains("gl_ARB_texture_cube_map"))
{
ARB_texture_cube_map = true;
extensions.Remove("glARB_texture_cube_map");
}
if (extensions.Contains("gl_ARB_texture_cube_map_array"))
{
ARB_texture_cube_map_array = true;
extensions.Remove("glARB_texture_cube_map_array");
}
if (extensions.Contains("gl_ARB_texture_env_add"))
{
ARB_texture_env_add = true;
extensions.Remove("glARB_texture_env_add");
}
if (extensions.Contains("gl_ARB_texture_env_combine"))
{
ARB_texture_env_combine = true;
extensions.Remove("glARB_texture_env_combine");
}
if (extensions.Contains("gl_ARB_texture_env_crossbar"))
{
ARB_texture_env_crossbar = true;
extensions.Remove("glARB_texture_env_crossbar");
}
if (extensions.Contains("gl_ARB_texture_env_dot3"))
{
ARB_texture_env_dot3 = true;
extensions.Remove("glARB_texture_env_dot3");
}
if (extensions.Contains("gl_ARB_texture_filter_anisotropic"))
{
ARB_texture_filter_anisotropic = true;
extensions.Remove("glARB_texture_filter_anisotropic");
}
if (extensions.Contains("gl_ARB_texture_filter_minmax"))
{
ARB_texture_filter_minmax = true;
extensions.Remove("glARB_texture_filter_minmax");
}
if (extensions.Contains("gl_ARB_texture_float"))
{
ARB_texture_float = true;
extensions.Remove("glARB_texture_float");
}
if (extensions.Contains("gl_ARB_texture_gather"))
{
ARB_texture_gather = true;
extensions.Remove("glARB_texture_gather");
}
if (extensions.Contains("gl_ARB_texture_mirror_clamp_to_edge"))
{
ARB_texture_mirror_clamp_to_edge = true;
extensions.Remove("glARB_texture_mirror_clamp_to_edge");
}
if (extensions.Contains("gl_ARB_texture_mirrored_repeat"))
{
ARB_texture_mirrored_repeat = true;
extensions.Remove("glARB_texture_mirrored_repeat");
}
if (extensions.Contains("gl_ARB_texture_multisample"))
{
ARB_texture_multisample = true;
extensions.Remove("glARB_texture_multisample");
}
if (extensions.Contains("gl_ARB_texture_non_power_of_two"))
{
ARB_texture_non_power_of_two = true;
extensions.Remove("glARB_texture_non_power_of_two");
}
if (extensions.Contains("gl_ARB_texture_query_levels"))
{
ARB_texture_query_levels = true;
extensions.Remove("glARB_texture_query_levels");
}
if (extensions.Contains("gl_ARB_texture_query_lod"))
{
ARB_texture_query_lod = true;
extensions.Remove("glARB_texture_query_lod");
}
if (extensions.Contains("gl_ARB_texture_rectangle"))
{
ARB_texture_rectangle = true;
extensions.Remove("glARB_texture_rectangle");
}
if (extensions.Contains("gl_ARB_texture_rg"))
{
ARB_texture_rg = true;
extensions.Remove("glARB_texture_rg");
}
if (extensions.Contains("gl_ARB_texture_rgb10_a2ui"))
{
ARB_texture_rgb10_a2ui = true;
extensions.Remove("glARB_texture_rgb10_a2ui");
}
if (extensions.Contains("gl_ARB_texture_stencil8"))
{
ARB_texture_stencil8 = true;
extensions.Remove("glARB_texture_stencil8");
}
if (extensions.Contains("gl_ARB_texture_storage"))
{
ARB_texture_storage = true;
extensions.Remove("glARB_texture_storage");
}
if (extensions.Contains("gl_ARB_texture_storage_multisample"))
{
ARB_texture_storage_multisample = true;
extensions.Remove("glARB_texture_storage_multisample");
}
if (extensions.Contains("gl_ARB_texture_swizzle"))
{
ARB_texture_swizzle = true;
extensions.Remove("glARB_texture_swizzle");
}
if (extensions.Contains("gl_ARB_texture_view"))
{
ARB_texture_view = true;
extensions.Remove("glARB_texture_view");
}
if (extensions.Contains("gl_ARB_timer_query"))
{
ARB_timer_query = true;
extensions.Remove("glARB_timer_query");
}
if (extensions.Contains("gl_ARB_transform_feedback2"))
{
ARB_transform_feedback2 = true;
extensions.Remove("glARB_transform_feedback2");
}
if (extensions.Contains("gl_ARB_transform_feedback3"))
{
ARB_transform_feedback3 = true;
extensions.Remove("glARB_transform_feedback3");
}
if (extensions.Contains("gl_ARB_transform_feedback_instanced"))
{
ARB_transform_feedback_instanced = true;
extensions.Remove("glARB_transform_feedback_instanced");
}
if (extensions.Contains("gl_ARB_transform_feedback_overflow_query"))
{
ARB_transform_feedback_overflow_query = true;
extensions.Remove("glARB_transform_feedback_overflow_query");
}
if (extensions.Contains("gl_ARB_transpose_matrix"))
{
ARB_transpose_matrix = true;
extensions.Remove("glARB_transpose_matrix");
}
if (extensions.Contains("gl_ARB_uniform_buffer_object"))
{
ARB_uniform_buffer_object = true;
extensions.Remove("glARB_uniform_buffer_object");
}
if (extensions.Contains("gl_ARB_vertex_array_bgra"))
{
ARB_vertex_array_bgra = true;
extensions.Remove("glARB_vertex_array_bgra");
}
if (extensions.Contains("gl_ARB_vertex_array_object"))
{
ARB_vertex_array_object = true;
extensions.Remove("glARB_vertex_array_object");
}
if (extensions.Contains("gl_ARB_vertex_attrib_64bit"))
{
ARB_vertex_attrib_64bit = true;
extensions.Remove("glARB_vertex_attrib_64bit");
}
if (extensions.Contains("gl_ARB_vertex_attrib_binding"))
{
ARB_vertex_attrib_binding = true;
extensions.Remove("glARB_vertex_attrib_binding");
}
if (extensions.Contains("gl_ARB_vertex_blend"))
{
ARB_vertex_blend = true;
extensions.Remove("glARB_vertex_blend");
}
if (extensions.Contains("gl_ARB_vertex_buffer_object"))
{
ARB_vertex_buffer_object = true;
extensions.Remove("glARB_vertex_buffer_object");
}
if (extensions.Contains("gl_ARB_vertex_program"))
{
ARB_vertex_program = true;
extensions.Remove("glARB_vertex_program");
}
if (extensions.Contains("gl_ARB_vertex_shader"))
{
ARB_vertex_shader = true;
extensions.Remove("glARB_vertex_shader");
}
if (extensions.Contains("gl_ARB_vertex_type_10f_11f_11f_rev"))
{
ARB_vertex_type_10f_11f_11f_rev = true;
extensions.Remove("glARB_vertex_type_10f_11f_11f_rev");
}
if (extensions.Contains("gl_ARB_vertex_type_2_10_10_10_rev"))
{
ARB_vertex_type_2_10_10_10_rev = true;
extensions.Remove("glARB_vertex_type_2_10_10_10_rev");
}
if (extensions.Contains("gl_ARB_viewport_array"))
{
ARB_viewport_array = true;
extensions.Remove("glARB_viewport_array");
}
if (extensions.Contains("gl_ARB_window_pos"))
{
ARB_window_pos = true;
extensions.Remove("glARB_window_pos");
}
if (extensions.Contains("gl_ATI_draw_buffers"))
{
ATI_draw_buffers = true;
extensions.Remove("glATI_draw_buffers");
}
if (extensions.Contains("gl_ATI_element_array"))
{
ATI_element_array = true;
extensions.Remove("glATI_element_array");
}
if (extensions.Contains("gl_ATI_envmap_bumpmap"))
{
ATI_envmap_bumpmap = true;
extensions.Remove("glATI_envmap_bumpmap");
}
if (extensions.Contains("gl_ATI_fragment_shader"))
{
ATI_fragment_shader = true;
extensions.Remove("glATI_fragment_shader");
}
if (extensions.Contains("gl_ATI_map_object_buffer"))
{
ATI_map_object_buffer = true;
extensions.Remove("glATI_map_object_buffer");
}
if (extensions.Contains("gl_ATI_meminfo"))
{
ATI_meminfo = true;
extensions.Remove("glATI_meminfo");
}
if (extensions.Contains("gl_ATI_pixel_format_float"))
{
ATI_pixel_format_float = true;
extensions.Remove("glATI_pixel_format_float");
}
if (extensions.Contains("gl_ATI_pn_triangles"))
{
ATI_pn_triangles = true;
extensions.Remove("glATI_pn_triangles");
}
if (extensions.Contains("gl_ATI_separate_stencil"))
{
ATI_separate_stencil = true;
extensions.Remove("glATI_separate_stencil");
}
if (extensions.Contains("gl_ATI_text_fragment_shader"))
{
ATI_text_fragment_shader = true;
extensions.Remove("glATI_text_fragment_shader");
}
if (extensions.Contains("gl_ATI_texture_env_combine3"))
{
ATI_texture_env_combine3 = true;
extensions.Remove("glATI_texture_env_combine3");
}
if (extensions.Contains("gl_ATI_texture_float"))
{
ATI_texture_float = true;
extensions.Remove("glATI_texture_float");
}
if (extensions.Contains("gl_ATI_texture_mirror_once"))
{
ATI_texture_mirror_once = true;
extensions.Remove("glATI_texture_mirror_once");
}
if (extensions.Contains("gl_ATI_vertex_array_object"))
{
ATI_vertex_array_object = true;
extensions.Remove("glATI_vertex_array_object");
}
if (extensions.Contains("gl_ATI_vertex_attrib_array_object"))
{
ATI_vertex_attrib_array_object = true;
extensions.Remove("glATI_vertex_attrib_array_object");
}
if (extensions.Contains("gl_ATI_vertex_streams"))
{
ATI_vertex_streams = true;
extensions.Remove("glATI_vertex_streams");
}
if (extensions.Contains("gl_EXT_422_pixels"))
{
EXT_422_pixels = true;
extensions.Remove("glEXT_422_pixels");
}
if (extensions.Contains("gl_EXT_EGL_image_storage"))
{
EXT_EGL_image_storage = true;
extensions.Remove("glEXT_EGL_image_storage");
}
if (extensions.Contains("gl_EXT_EGL_sync"))
{
EXT_EGL_sync = true;
extensions.Remove("glEXT_EGL_sync");
}
if (extensions.Contains("gl_EXT_abgr"))
{
EXT_abgr = true;
extensions.Remove("glEXT_abgr");
}
if (extensions.Contains("gl_EXT_bgra"))
{
EXT_bgra = true;
extensions.Remove("glEXT_bgra");
}
if (extensions.Contains("gl_EXT_bindable_uniform"))
{
EXT_bindable_uniform = true;
extensions.Remove("glEXT_bindable_uniform");
}
if (extensions.Contains("gl_EXT_blend_color"))
{
EXT_blend_color = true;
extensions.Remove("glEXT_blend_color");
}
if (extensions.Contains("gl_EXT_blend_equation_separate"))
{
EXT_blend_equation_separate = true;
extensions.Remove("glEXT_blend_equation_separate");
}
if (extensions.Contains("gl_EXT_blend_func_separate"))
{
EXT_blend_func_separate = true;
extensions.Remove("glEXT_blend_func_separate");
}
if (extensions.Contains("gl_EXT_blend_logic_op"))
{
EXT_blend_logic_op = true;
extensions.Remove("glEXT_blend_logic_op");
}
if (extensions.Contains("gl_EXT_blend_minmax"))
{
EXT_blend_minmax = true;
extensions.Remove("glEXT_blend_minmax");
}
if (extensions.Contains("gl_EXT_blend_subtract"))
{
EXT_blend_subtract = true;
extensions.Remove("glEXT_blend_subtract");
}
if (extensions.Contains("gl_EXT_clip_volume_hint"))
{
EXT_clip_volume_hint = true;
extensions.Remove("glEXT_clip_volume_hint");
}
if (extensions.Contains("gl_EXT_cmyka"))
{
EXT_cmyka = true;
extensions.Remove("glEXT_cmyka");
}
if (extensions.Contains("gl_EXT_color_subtable"))
{
EXT_color_subtable = true;
extensions.Remove("glEXT_color_subtable");
}
if (extensions.Contains("gl_EXT_compiled_vertex_array"))
{
EXT_compiled_vertex_array = true;
extensions.Remove("glEXT_compiled_vertex_array");
}
if (extensions.Contains("gl_EXT_convolution"))
{
EXT_convolution = true;
extensions.Remove("glEXT_convolution");
}
if (extensions.Contains("gl_EXT_coordinate_frame"))
{
EXT_coordinate_frame = true;
extensions.Remove("glEXT_coordinate_frame");
}
if (extensions.Contains("gl_EXT_copy_texture"))
{
EXT_copy_texture = true;
extensions.Remove("glEXT_copy_texture");
}
if (extensions.Contains("gl_EXT_cull_vertex"))
{
EXT_cull_vertex = true;
extensions.Remove("glEXT_cull_vertex");
}
if (extensions.Contains("gl_EXT_debug_label"))
{
EXT_debug_label = true;
extensions.Remove("glEXT_debug_label");
}
if (extensions.Contains("gl_EXT_debug_marker"))
{
EXT_debug_marker = true;
extensions.Remove("glEXT_debug_marker");
}
if (extensions.Contains("gl_EXT_depth_bounds_test"))
{
EXT_depth_bounds_test = true;
extensions.Remove("glEXT_depth_bounds_test");
}
if (extensions.Contains("gl_EXT_direct_state_access"))
{
EXT_direct_state_access = true;
extensions.Remove("glEXT_direct_state_access");
}
if (extensions.Contains("gl_EXT_draw_buffers2"))
{
EXT_draw_buffers2 = true;
extensions.Remove("glEXT_draw_buffers2");
}
if (extensions.Contains("gl_EXT_draw_instanced"))
{
EXT_draw_instanced = true;
extensions.Remove("glEXT_draw_instanced");
}
if (extensions.Contains("gl_EXT_draw_range_elements"))
{
EXT_draw_range_elements = true;
extensions.Remove("glEXT_draw_range_elements");
}
if (extensions.Contains("gl_EXT_external_buffer"))
{
EXT_external_buffer = true;
extensions.Remove("glEXT_external_buffer");
}
if (extensions.Contains("gl_EXT_fog_coord"))
{
EXT_fog_coord = true;
extensions.Remove("glEXT_fog_coord");
}
if (extensions.Contains("gl_EXT_framebuffer_blit"))
{
EXT_framebuffer_blit = true;
extensions.Remove("glEXT_framebuffer_blit");
}
if (extensions.Contains("gl_EXT_framebuffer_blit_layers"))
{
EXT_framebuffer_blit_layers = true;
extensions.Remove("glEXT_framebuffer_blit_layers");
}
if (extensions.Contains("gl_EXT_framebuffer_multisample"))
{
EXT_framebuffer_multisample = true;
extensions.Remove("glEXT_framebuffer_multisample");
}
if (extensions.Contains("gl_EXT_framebuffer_multisample_blit_scaled"))
{
EXT_framebuffer_multisample_blit_scaled = true;
extensions.Remove("glEXT_framebuffer_multisample_blit_scaled");
}
if (extensions.Contains("gl_EXT_framebuffer_object"))
{
EXT_framebuffer_object = true;
extensions.Remove("glEXT_framebuffer_object");
}
if (extensions.Contains("gl_EXT_framebuffer_sRGB"))
{
EXT_framebuffer_sRGB = true;
extensions.Remove("glEXT_framebuffer_sRGB");
}
if (extensions.Contains("gl_EXT_geometry_shader4"))
{
EXT_geometry_shader4 = true;
extensions.Remove("glEXT_geometry_shader4");
}
if (extensions.Contains("gl_EXT_gpu_program_parameters"))
{
EXT_gpu_program_parameters = true;
extensions.Remove("glEXT_gpu_program_parameters");
}
if (extensions.Contains("gl_EXT_gpu_shader4"))
{
EXT_gpu_shader4 = true;
extensions.Remove("glEXT_gpu_shader4");
}
if (extensions.Contains("gl_EXT_histogram"))
{
EXT_histogram = true;
extensions.Remove("glEXT_histogram");
}
if (extensions.Contains("gl_EXT_index_array_formats"))
{
EXT_index_array_formats = true;
extensions.Remove("glEXT_index_array_formats");
}
if (extensions.Contains("gl_EXT_index_func"))
{
EXT_index_func = true;
extensions.Remove("glEXT_index_func");
}
if (extensions.Contains("gl_EXT_index_material"))
{
EXT_index_material = true;
extensions.Remove("glEXT_index_material");
}
if (extensions.Contains("gl_EXT_index_texture"))
{
EXT_index_texture = true;
extensions.Remove("glEXT_index_texture");
}
if (extensions.Contains("gl_EXT_light_texture"))
{
EXT_light_texture = true;
extensions.Remove("glEXT_light_texture");
}
if (extensions.Contains("gl_EXT_memory_object"))
{
EXT_memory_object = true;
extensions.Remove("glEXT_memory_object");
}
if (extensions.Contains("gl_EXT_memory_object_fd"))
{
EXT_memory_object_fd = true;
extensions.Remove("glEXT_memory_object_fd");
}
if (extensions.Contains("gl_EXT_memory_object_win32"))
{
EXT_memory_object_win32 = true;
extensions.Remove("glEXT_memory_object_win32");
}
if (extensions.Contains("gl_EXT_misc_attribute"))
{
EXT_misc_attribute = true;
extensions.Remove("glEXT_misc_attribute");
}
if (extensions.Contains("gl_EXT_multi_draw_arrays"))
{
EXT_multi_draw_arrays = true;
extensions.Remove("glEXT_multi_draw_arrays");
}
if (extensions.Contains("gl_EXT_multisample"))
{
EXT_multisample = true;
extensions.Remove("glEXT_multisample");
}
if (extensions.Contains("gl_EXT_multiview_tessellation_geometry_shader"))
{
EXT_multiview_tessellation_geometry_shader = true;
extensions.Remove("glEXT_multiview_tessellation_geometry_shader");
}
if (extensions.Contains("gl_EXT_multiview_texture_multisample"))
{
EXT_multiview_texture_multisample = true;
extensions.Remove("glEXT_multiview_texture_multisample");
}
if (extensions.Contains("gl_EXT_multiview_timer_query"))
{
EXT_multiview_timer_query = true;
extensions.Remove("glEXT_multiview_timer_query");
}
if (extensions.Contains("gl_EXT_packed_depth_stencil"))
{
EXT_packed_depth_stencil = true;
extensions.Remove("glEXT_packed_depth_stencil");
}
if (extensions.Contains("gl_EXT_packed_float"))
{
EXT_packed_float = true;
extensions.Remove("glEXT_packed_float");
}
if (extensions.Contains("gl_EXT_packed_pixels"))
{
EXT_packed_pixels = true;
extensions.Remove("glEXT_packed_pixels");
}
if (extensions.Contains("gl_EXT_paletted_texture"))
{
EXT_paletted_texture = true;
extensions.Remove("glEXT_paletted_texture");
}
if (extensions.Contains("gl_EXT_pixel_buffer_object"))
{
EXT_pixel_buffer_object = true;
extensions.Remove("glEXT_pixel_buffer_object");
}
if (extensions.Contains("gl_EXT_pixel_transform"))
{
EXT_pixel_transform = true;
extensions.Remove("glEXT_pixel_transform");
}
if (extensions.Contains("gl_EXT_pixel_transform_color_table"))
{
EXT_pixel_transform_color_table = true;
extensions.Remove("glEXT_pixel_transform_color_table");
}
if (extensions.Contains("gl_EXT_point_parameters"))
{
EXT_point_parameters = true;
extensions.Remove("glEXT_point_parameters");
}
if (extensions.Contains("gl_EXT_polygon_offset"))
{
EXT_polygon_offset = true;
extensions.Remove("glEXT_polygon_offset");
}
if (extensions.Contains("gl_EXT_polygon_offset_clamp"))
{
EXT_polygon_offset_clamp = true;
extensions.Remove("glEXT_polygon_offset_clamp");
}
if (extensions.Contains("gl_EXT_post_depth_coverage"))
{
EXT_post_depth_coverage = true;
extensions.Remove("glEXT_post_depth_coverage");
}
if (extensions.Contains("gl_EXT_provoking_vertex"))
{
EXT_provoking_vertex = true;
extensions.Remove("glEXT_provoking_vertex");
}
if (extensions.Contains("gl_EXT_raster_multisample"))
{
EXT_raster_multisample = true;
extensions.Remove("glEXT_raster_multisample");
}
if (extensions.Contains("gl_EXT_rescale_normal"))
{
EXT_rescale_normal = true;
extensions.Remove("glEXT_rescale_normal");
}
if (extensions.Contains("gl_EXT_secondary_color"))
{
EXT_secondary_color = true;
extensions.Remove("glEXT_secondary_color");
}
if (extensions.Contains("gl_EXT_semaphore"))
{
EXT_semaphore = true;
extensions.Remove("glEXT_semaphore");
}
if (extensions.Contains("gl_EXT_semaphore_fd"))
{
EXT_semaphore_fd = true;
extensions.Remove("glEXT_semaphore_fd");
}
if (extensions.Contains("gl_EXT_semaphore_win32"))
{
EXT_semaphore_win32 = true;
extensions.Remove("glEXT_semaphore_win32");
}
if (extensions.Contains("gl_EXT_separate_shader_objects"))
{
EXT_separate_shader_objects = true;
extensions.Remove("glEXT_separate_shader_objects");
}
if (extensions.Contains("gl_EXT_separate_specular_color"))
{
EXT_separate_specular_color = true;
extensions.Remove("glEXT_separate_specular_color");
}
if (extensions.Contains("gl_EXT_shader_framebuffer_fetch"))
{
EXT_shader_framebuffer_fetch = true;
extensions.Remove("glEXT_shader_framebuffer_fetch");
}
if (extensions.Contains("gl_EXT_shader_framebuffer_fetch_non_coherent"))
{
EXT_shader_framebuffer_fetch_non_coherent = true;
extensions.Remove("glEXT_shader_framebuffer_fetch_non_coherent");
}
if (extensions.Contains("gl_EXT_shader_image_load_formatted"))
{
EXT_shader_image_load_formatted = true;
extensions.Remove("glEXT_shader_image_load_formatted");
}
if (extensions.Contains("gl_EXT_shader_image_load_store"))
{
EXT_shader_image_load_store = true;
extensions.Remove("glEXT_shader_image_load_store");
}
if (extensions.Contains("gl_EXT_shader_integer_mix"))
{
EXT_shader_integer_mix = true;
extensions.Remove("glEXT_shader_integer_mix");
}
if (extensions.Contains("gl_EXT_shader_samples_identical"))
{
EXT_shader_samples_identical = true;
extensions.Remove("glEXT_shader_samples_identical");
}
if (extensions.Contains("gl_EXT_shadow_funcs"))
{
EXT_shadow_funcs = true;
extensions.Remove("glEXT_shadow_funcs");
}
if (extensions.Contains("gl_EXT_shared_texture_palette"))
{
EXT_shared_texture_palette = true;
extensions.Remove("glEXT_shared_texture_palette");
}
if (extensions.Contains("gl_EXT_sparse_texture2"))
{
EXT_sparse_texture2 = true;
extensions.Remove("glEXT_sparse_texture2");
}
if (extensions.Contains("gl_EXT_stencil_clear_tag"))
{
EXT_stencil_clear_tag = true;
extensions.Remove("glEXT_stencil_clear_tag");
}
if (extensions.Contains("gl_EXT_stencil_two_side"))
{
EXT_stencil_two_side = true;
extensions.Remove("glEXT_stencil_two_side");
}
if (extensions.Contains("gl_EXT_stencil_wrap"))
{
EXT_stencil_wrap = true;
extensions.Remove("glEXT_stencil_wrap");
}
if (extensions.Contains("gl_EXT_subtexture"))
{
EXT_subtexture = true;
extensions.Remove("glEXT_subtexture");
}
if (extensions.Contains("gl_EXT_texture"))
{
EXT_texture = true;
extensions.Remove("glEXT_texture");
}
if (extensions.Contains("gl_EXT_texture3D"))
{
EXT_texture3D = true;
extensions.Remove("glEXT_texture3D");
}
if (extensions.Contains("gl_EXT_texture_array"))
{
EXT_texture_array = true;
extensions.Remove("glEXT_texture_array");
}
if (extensions.Contains("gl_EXT_texture_buffer_object"))
{
EXT_texture_buffer_object = true;
extensions.Remove("glEXT_texture_buffer_object");
}
if (extensions.Contains("gl_EXT_texture_compression_latc"))
{
EXT_texture_compression_latc = true;
extensions.Remove("glEXT_texture_compression_latc");
}
if (extensions.Contains("gl_EXT_texture_compression_rgtc"))
{
EXT_texture_compression_rgtc = true;
extensions.Remove("glEXT_texture_compression_rgtc");
}
if (extensions.Contains("gl_EXT_texture_compression_s3tc"))
{
EXT_texture_compression_s3tc = true;
extensions.Remove("glEXT_texture_compression_s3tc");
}
if (extensions.Contains("gl_EXT_texture_cube_map"))
{
EXT_texture_cube_map = true;
extensions.Remove("glEXT_texture_cube_map");
}
if (extensions.Contains("gl_EXT_texture_env_add"))
{
EXT_texture_env_add = true;
extensions.Remove("glEXT_texture_env_add");
}
if (extensions.Contains("gl_EXT_texture_env_combine"))
{
EXT_texture_env_combine = true;
extensions.Remove("glEXT_texture_env_combine");
}
if (extensions.Contains("gl_EXT_texture_env_dot3"))
{
EXT_texture_env_dot3 = true;
extensions.Remove("glEXT_texture_env_dot3");
}
if (extensions.Contains("gl_EXT_texture_filter_anisotropic"))
{
EXT_texture_filter_anisotropic = true;
extensions.Remove("glEXT_texture_filter_anisotropic");
}
if (extensions.Contains("gl_EXT_texture_filter_minmax"))
{
EXT_texture_filter_minmax = true;
extensions.Remove("glEXT_texture_filter_minmax");
}
if (extensions.Contains("gl_EXT_texture_integer"))
{
EXT_texture_integer = true;
extensions.Remove("glEXT_texture_integer");
}
if (extensions.Contains("gl_EXT_texture_lod_bias"))
{
EXT_texture_lod_bias = true;
extensions.Remove("glEXT_texture_lod_bias");
}
if (extensions.Contains("gl_EXT_texture_mirror_clamp"))
{
EXT_texture_mirror_clamp = true;
extensions.Remove("glEXT_texture_mirror_clamp");
}
if (extensions.Contains("gl_EXT_texture_object"))
{
EXT_texture_object = true;
extensions.Remove("glEXT_texture_object");
}
if (extensions.Contains("gl_EXT_texture_perturb_normal"))
{
EXT_texture_perturb_normal = true;
extensions.Remove("glEXT_texture_perturb_normal");
}
if (extensions.Contains("gl_EXT_texture_sRGB"))
{
EXT_texture_sRGB = true;
extensions.Remove("glEXT_texture_sRGB");
}
if (extensions.Contains("gl_EXT_texture_sRGB_R8"))
{
EXT_texture_sRGB_R8 = true;
extensions.Remove("glEXT_texture_sRGB_R8");
}
if (extensions.Contains("gl_EXT_texture_sRGB_RG8"))
{
EXT_texture_sRGB_RG8 = true;
extensions.Remove("glEXT_texture_sRGB_RG8");
}
if (extensions.Contains("gl_EXT_texture_sRGB_decode"))
{
EXT_texture_sRGB_decode = true;
extensions.Remove("glEXT_texture_sRGB_decode");
}
if (extensions.Contains("gl_EXT_texture_shadow_lod"))
{
EXT_texture_shadow_lod = true;
extensions.Remove("glEXT_texture_shadow_lod");
}
if (extensions.Contains("gl_EXT_texture_shared_exponent"))
{
EXT_texture_shared_exponent = true;
extensions.Remove("glEXT_texture_shared_exponent");
}
if (extensions.Contains("gl_EXT_texture_snorm"))
{
EXT_texture_snorm = true;
extensions.Remove("glEXT_texture_snorm");
}
if (extensions.Contains("gl_EXT_texture_storage"))
{
EXT_texture_storage = true;
extensions.Remove("glEXT_texture_storage");
}
if (extensions.Contains("gl_EXT_texture_swizzle"))
{
EXT_texture_swizzle = true;
extensions.Remove("glEXT_texture_swizzle");
}
if (extensions.Contains("gl_EXT_timer_query"))
{
EXT_timer_query = true;
extensions.Remove("glEXT_timer_query");
}
if (extensions.Contains("gl_EXT_transform_feedback"))
{
EXT_transform_feedback = true;
extensions.Remove("glEXT_transform_feedback");
}
if (extensions.Contains("gl_EXT_vertex_array"))
{
EXT_vertex_array = true;
extensions.Remove("glEXT_vertex_array");
}
if (extensions.Contains("gl_EXT_vertex_array_bgra"))
{
EXT_vertex_array_bgra = true;
extensions.Remove("glEXT_vertex_array_bgra");
}
if (extensions.Contains("gl_EXT_vertex_attrib_64bit"))
{
EXT_vertex_attrib_64bit = true;
extensions.Remove("glEXT_vertex_attrib_64bit");
}
if (extensions.Contains("gl_EXT_vertex_shader"))
{
EXT_vertex_shader = true;
extensions.Remove("glEXT_vertex_shader");
}
if (extensions.Contains("gl_EXT_vertex_weighting"))
{
EXT_vertex_weighting = true;
extensions.Remove("glEXT_vertex_weighting");
}
if (extensions.Contains("gl_EXT_win32_keyed_mutex"))
{
EXT_win32_keyed_mutex = true;
extensions.Remove("glEXT_win32_keyed_mutex");
}
if (extensions.Contains("gl_EXT_window_rectangles"))
{
EXT_window_rectangles = true;
extensions.Remove("glEXT_window_rectangles");
}
if (extensions.Contains("gl_EXT_x11_sync_object"))
{
EXT_x11_sync_object = true;
extensions.Remove("glEXT_x11_sync_object");
}
if (extensions.Contains("gl_GREMEDY_frame_terminator"))
{
GREMEDY_frame_terminator = true;
extensions.Remove("glGREMEDY_frame_terminator");
}
if (extensions.Contains("gl_GREMEDY_string_marker"))
{
GREMEDY_string_marker = true;
extensions.Remove("glGREMEDY_string_marker");
}
if (extensions.Contains("gl_HP_convolution_border_modes"))
{
HP_convolution_border_modes = true;
extensions.Remove("glHP_convolution_border_modes");
}
if (extensions.Contains("gl_HP_image_transform"))
{
HP_image_transform = true;
extensions.Remove("glHP_image_transform");
}
if (extensions.Contains("gl_HP_occlusion_test"))
{
HP_occlusion_test = true;
extensions.Remove("glHP_occlusion_test");
}
if (extensions.Contains("gl_HP_texture_lighting"))
{
HP_texture_lighting = true;
extensions.Remove("glHP_texture_lighting");
}
if (extensions.Contains("gl_IBM_cull_vertex"))
{
IBM_cull_vertex = true;
extensions.Remove("glIBM_cull_vertex");
}
if (extensions.Contains("gl_IBM_multimode_draw_arrays"))
{
IBM_multimode_draw_arrays = true;
extensions.Remove("glIBM_multimode_draw_arrays");
}
if (extensions.Contains("gl_IBM_rasterpos_clip"))
{
IBM_rasterpos_clip = true;
extensions.Remove("glIBM_rasterpos_clip");
}
if (extensions.Contains("gl_IBM_static_data"))
{
IBM_static_data = true;
extensions.Remove("glIBM_static_data");
}
if (extensions.Contains("gl_IBM_texture_mirrored_repeat"))
{
IBM_texture_mirrored_repeat = true;
extensions.Remove("glIBM_texture_mirrored_repeat");
}
if (extensions.Contains("gl_IBM_vertex_array_lists"))
{
IBM_vertex_array_lists = true;
extensions.Remove("glIBM_vertex_array_lists");
}
if (extensions.Contains("gl_INGR_blend_func_separate"))
{
INGR_blend_func_separate = true;
extensions.Remove("glINGR_blend_func_separate");
}
if (extensions.Contains("gl_INGR_color_clamp"))
{
INGR_color_clamp = true;
extensions.Remove("glINGR_color_clamp");
}
if (extensions.Contains("gl_INGR_interlace_read"))
{
INGR_interlace_read = true;
extensions.Remove("glINGR_interlace_read");
}
if (extensions.Contains("gl_INTEL_blackhole_render"))
{
INTEL_blackhole_render = true;
extensions.Remove("glINTEL_blackhole_render");
}
if (extensions.Contains("gl_INTEL_conservative_rasterization"))
{
INTEL_conservative_rasterization = true;
extensions.Remove("glINTEL_conservative_rasterization");
}
if (extensions.Contains("gl_INTEL_fragment_shader_ordering"))
{
INTEL_fragment_shader_ordering = true;
extensions.Remove("glINTEL_fragment_shader_ordering");
}
if (extensions.Contains("gl_INTEL_framebuffer_CMAA"))
{
INTEL_framebuffer_CMAA = true;
extensions.Remove("glINTEL_framebuffer_CMAA");
}
if (extensions.Contains("gl_INTEL_map_texture"))
{
INTEL_map_texture = true;
extensions.Remove("glINTEL_map_texture");
}
if (extensions.Contains("gl_INTEL_parallel_arrays"))
{
INTEL_parallel_arrays = true;
extensions.Remove("glINTEL_parallel_arrays");
}
if (extensions.Contains("gl_INTEL_performance_query"))
{
INTEL_performance_query = true;
extensions.Remove("glINTEL_performance_query");
}
if (extensions.Contains("gl_KHR_blend_equation_advanced"))
{
KHR_blend_equation_advanced = true;
extensions.Remove("glKHR_blend_equation_advanced");
}
if (extensions.Contains("gl_KHR_blend_equation_advanced_coherent"))
{
KHR_blend_equation_advanced_coherent = true;
extensions.Remove("glKHR_blend_equation_advanced_coherent");
}
if (extensions.Contains("gl_KHR_context_flush_control"))
{
KHR_context_flush_control = true;
extensions.Remove("glKHR_context_flush_control");
}
if (extensions.Contains("gl_KHR_debug"))
{
KHR_debug = true;
extensions.Remove("glKHR_debug");
}
if (extensions.Contains("gl_KHR_no_error"))
{
KHR_no_error = true;
extensions.Remove("glKHR_no_error");
}
if (extensions.Contains("gl_KHR_parallel_shader_compile"))
{
KHR_parallel_shader_compile = true;
extensions.Remove("glKHR_parallel_shader_compile");
}
if (extensions.Contains("gl_KHR_robust_buffer_access_behavior"))
{
KHR_robust_buffer_access_behavior = true;
extensions.Remove("glKHR_robust_buffer_access_behavior");
}
if (extensions.Contains("gl_KHR_robustness"))
{
KHR_robustness = true;
extensions.Remove("glKHR_robustness");
}
if (extensions.Contains("gl_KHR_shader_subgroup"))
{
KHR_shader_subgroup = true;
extensions.Remove("glKHR_shader_subgroup");
}
if (extensions.Contains("gl_KHR_texture_compression_astc_hdr"))
{
KHR_texture_compression_astc_hdr = true;
extensions.Remove("glKHR_texture_compression_astc_hdr");
}
if (extensions.Contains("gl_KHR_texture_compression_astc_ldr"))
{
KHR_texture_compression_astc_ldr = true;
extensions.Remove("glKHR_texture_compression_astc_ldr");
}
if (extensions.Contains("gl_KHR_texture_compression_astc_sliced_3d"))
{
KHR_texture_compression_astc_sliced_3d = true;
extensions.Remove("glKHR_texture_compression_astc_sliced_3d");
}
if (extensions.Contains("gl_MESAX_texture_stack"))
{
MESAX_texture_stack = true;
extensions.Remove("glMESAX_texture_stack");
}
if (extensions.Contains("gl_MESA_framebuffer_flip_x"))
{
MESA_framebuffer_flip_x = true;
extensions.Remove("glMESA_framebuffer_flip_x");
}
if (extensions.Contains("gl_MESA_framebuffer_flip_y"))
{
MESA_framebuffer_flip_y = true;
extensions.Remove("glMESA_framebuffer_flip_y");
}
if (extensions.Contains("gl_MESA_framebuffer_swap_xy"))
{
MESA_framebuffer_swap_xy = true;
extensions.Remove("glMESA_framebuffer_swap_xy");
}
if (extensions.Contains("gl_MESA_pack_invert"))
{
MESA_pack_invert = true;
extensions.Remove("glMESA_pack_invert");
}
if (extensions.Contains("gl_MESA_program_binary_formats"))
{
MESA_program_binary_formats = true;
extensions.Remove("glMESA_program_binary_formats");
}
if (extensions.Contains("gl_MESA_resize_buffers"))
{
MESA_resize_buffers = true;
extensions.Remove("glMESA_resize_buffers");
}
if (extensions.Contains("gl_MESA_shader_integer_functions"))
{
MESA_shader_integer_functions = true;
extensions.Remove("glMESA_shader_integer_functions");
}
if (extensions.Contains("gl_MESA_tile_raster_order"))
{
MESA_tile_raster_order = true;
extensions.Remove("glMESA_tile_raster_order");
}
if (extensions.Contains("gl_MESA_window_pos"))
{
MESA_window_pos = true;
extensions.Remove("glMESA_window_pos");
}
if (extensions.Contains("gl_MESA_ycbcr_texture"))
{
MESA_ycbcr_texture = true;
extensions.Remove("glMESA_ycbcr_texture");
}
if (extensions.Contains("gl_NVX_blend_equation_advanced_multi_draw_buffers"))
{
NVX_blend_equation_advanced_multi_draw_buffers = true;
extensions.Remove("glNVX_blend_equation_advanced_multi_draw_buffers");
}
if (extensions.Contains("gl_NVX_conditional_render"))
{
NVX_conditional_render = true;
extensions.Remove("glNVX_conditional_render");
}
if (extensions.Contains("gl_NVX_gpu_memory_info"))
{
NVX_gpu_memory_info = true;
extensions.Remove("glNVX_gpu_memory_info");
}
if (extensions.Contains("gl_NVX_gpu_multicast2"))
{
NVX_gpu_multicast2 = true;
extensions.Remove("glNVX_gpu_multicast2");
}
if (extensions.Contains("gl_NVX_linked_gpu_multicast"))
{
NVX_linked_gpu_multicast = true;
extensions.Remove("glNVX_linked_gpu_multicast");
}
if (extensions.Contains("gl_NVX_progress_fence"))
{
NVX_progress_fence = true;
extensions.Remove("glNVX_progress_fence");
}
if (extensions.Contains("gl_NV_alpha_to_coverage_dither_control"))
{
NV_alpha_to_coverage_dither_control = true;
extensions.Remove("glNV_alpha_to_coverage_dither_control");
}
if (extensions.Contains("gl_NV_bindless_multi_draw_indirect"))
{
NV_bindless_multi_draw_indirect = true;
extensions.Remove("glNV_bindless_multi_draw_indirect");
}
if (extensions.Contains("gl_NV_bindless_multi_draw_indirect_count"))
{
NV_bindless_multi_draw_indirect_count = true;
extensions.Remove("glNV_bindless_multi_draw_indirect_count");
}
if (extensions.Contains("gl_NV_bindless_texture"))
{
NV_bindless_texture = true;
extensions.Remove("glNV_bindless_texture");
}
if (extensions.Contains("gl_NV_blend_equation_advanced"))
{
NV_blend_equation_advanced = true;
extensions.Remove("glNV_blend_equation_advanced");
}
if (extensions.Contains("gl_NV_blend_equation_advanced_coherent"))
{
NV_blend_equation_advanced_coherent = true;
extensions.Remove("glNV_blend_equation_advanced_coherent");
}
if (extensions.Contains("gl_NV_blend_minmax_factor"))
{
NV_blend_minmax_factor = true;
extensions.Remove("glNV_blend_minmax_factor");
}
if (extensions.Contains("gl_NV_blend_square"))
{
NV_blend_square = true;
extensions.Remove("glNV_blend_square");
}
if (extensions.Contains("gl_NV_clip_space_w_scaling"))
{
NV_clip_space_w_scaling = true;
extensions.Remove("glNV_clip_space_w_scaling");
}
if (extensions.Contains("gl_NV_command_list"))
{
NV_command_list = true;
extensions.Remove("glNV_command_list");
}
if (extensions.Contains("gl_NV_compute_program5"))
{
NV_compute_program5 = true;
extensions.Remove("glNV_compute_program5");
}
if (extensions.Contains("gl_NV_compute_shader_derivatives"))
{
NV_compute_shader_derivatives = true;
extensions.Remove("glNV_compute_shader_derivatives");
}
if (extensions.Contains("gl_NV_conditional_render"))
{
NV_conditional_render = true;
extensions.Remove("glNV_conditional_render");
}
if (extensions.Contains("gl_NV_conservative_raster"))
{
NV_conservative_raster = true;
extensions.Remove("glNV_conservative_raster");
}
if (extensions.Contains("gl_NV_conservative_raster_dilate"))
{
NV_conservative_raster_dilate = true;
extensions.Remove("glNV_conservative_raster_dilate");
}
if (extensions.Contains("gl_NV_conservative_raster_pre_snap"))
{
NV_conservative_raster_pre_snap = true;
extensions.Remove("glNV_conservative_raster_pre_snap");
}
if (extensions.Contains("gl_NV_conservative_raster_pre_snap_triangles"))
{
NV_conservative_raster_pre_snap_triangles = true;
extensions.Remove("glNV_conservative_raster_pre_snap_triangles");
}
if (extensions.Contains("gl_NV_conservative_raster_underestimation"))
{
NV_conservative_raster_underestimation = true;
extensions.Remove("glNV_conservative_raster_underestimation");
}
if (extensions.Contains("gl_NV_copy_depth_to_color"))
{
NV_copy_depth_to_color = true;
extensions.Remove("glNV_copy_depth_to_color");
}
if (extensions.Contains("gl_NV_copy_image"))
{
NV_copy_image = true;
extensions.Remove("glNV_copy_image");
}
if (extensions.Contains("gl_NV_deep_texture3D"))
{
NV_deep_texture3D = true;
extensions.Remove("glNV_deep_texture3D");
}
if (extensions.Contains("gl_NV_depth_buffer_float"))
{
NV_depth_buffer_float = true;
extensions.Remove("glNV_depth_buffer_float");
}
if (extensions.Contains("gl_NV_depth_clamp"))
{
NV_depth_clamp = true;
extensions.Remove("glNV_depth_clamp");
}
if (extensions.Contains("gl_NV_draw_texture"))
{
NV_draw_texture = true;
extensions.Remove("glNV_draw_texture");
}
if (extensions.Contains("gl_NV_draw_vulkan_image"))
{
NV_draw_vulkan_image = true;
extensions.Remove("glNV_draw_vulkan_image");
}
if (extensions.Contains("gl_NV_evaluators"))
{
NV_evaluators = true;
extensions.Remove("glNV_evaluators");
}
if (extensions.Contains("gl_NV_explicit_multisample"))
{
NV_explicit_multisample = true;
extensions.Remove("glNV_explicit_multisample");
}
if (extensions.Contains("gl_NV_fence"))
{
NV_fence = true;
extensions.Remove("glNV_fence");
}
if (extensions.Contains("gl_NV_fill_rectangle"))
{
NV_fill_rectangle = true;
extensions.Remove("glNV_fill_rectangle");
}
if (extensions.Contains("gl_NV_float_buffer"))
{
NV_float_buffer = true;
extensions.Remove("glNV_float_buffer");
}
if (extensions.Contains("gl_NV_fog_distance"))
{
NV_fog_distance = true;
extensions.Remove("glNV_fog_distance");
}
if (extensions.Contains("gl_NV_fragment_coverage_to_color"))
{
NV_fragment_coverage_to_color = true;
extensions.Remove("glNV_fragment_coverage_to_color");
}
if (extensions.Contains("gl_NV_fragment_program"))
{
NV_fragment_program = true;
extensions.Remove("glNV_fragment_program");
}
if (extensions.Contains("gl_NV_fragment_program2"))
{
NV_fragment_program2 = true;
extensions.Remove("glNV_fragment_program2");
}
if (extensions.Contains("gl_NV_fragment_program4"))
{
NV_fragment_program4 = true;
extensions.Remove("glNV_fragment_program4");
}
if (extensions.Contains("gl_NV_fragment_program_option"))
{
NV_fragment_program_option = true;
extensions.Remove("glNV_fragment_program_option");
}
if (extensions.Contains("gl_NV_fragment_shader_barycentric"))
{
NV_fragment_shader_barycentric = true;
extensions.Remove("glNV_fragment_shader_barycentric");
}
if (extensions.Contains("gl_NV_fragment_shader_interlock"))
{
NV_fragment_shader_interlock = true;
extensions.Remove("glNV_fragment_shader_interlock");
}
if (extensions.Contains("gl_NV_framebuffer_mixed_samples"))
{
NV_framebuffer_mixed_samples = true;
extensions.Remove("glNV_framebuffer_mixed_samples");
}
if (extensions.Contains("gl_NV_framebuffer_multisample_coverage"))
{
NV_framebuffer_multisample_coverage = true;
extensions.Remove("glNV_framebuffer_multisample_coverage");
}
if (extensions.Contains("gl_NV_geometry_program4"))
{
NV_geometry_program4 = true;
extensions.Remove("glNV_geometry_program4");
}
if (extensions.Contains("gl_NV_geometry_shader4"))
{
NV_geometry_shader4 = true;
extensions.Remove("glNV_geometry_shader4");
}
if (extensions.Contains("gl_NV_geometry_shader_passthrough"))
{
NV_geometry_shader_passthrough = true;
extensions.Remove("glNV_geometry_shader_passthrough");
}
if (extensions.Contains("gl_NV_gpu_multicast"))
{
NV_gpu_multicast = true;
extensions.Remove("glNV_gpu_multicast");
}
if (extensions.Contains("gl_NV_gpu_program4"))
{
NV_gpu_program4 = true;
extensions.Remove("glNV_gpu_program4");
}
if (extensions.Contains("gl_NV_gpu_program5"))
{
NV_gpu_program5 = true;
extensions.Remove("glNV_gpu_program5");
}
if (extensions.Contains("gl_NV_gpu_program5_mem_extended"))
{
NV_gpu_program5_mem_extended = true;
extensions.Remove("glNV_gpu_program5_mem_extended");
}
if (extensions.Contains("gl_NV_gpu_shader5"))
{
NV_gpu_shader5 = true;
extensions.Remove("glNV_gpu_shader5");
}
if (extensions.Contains("gl_NV_half_float"))
{
NV_half_float = true;
extensions.Remove("glNV_half_float");
}
if (extensions.Contains("gl_NV_internalformat_sample_query"))
{
NV_internalformat_sample_query = true;
extensions.Remove("glNV_internalformat_sample_query");
}
if (extensions.Contains("gl_NV_light_max_exponent"))
{
NV_light_max_exponent = true;
extensions.Remove("glNV_light_max_exponent");
}
if (extensions.Contains("gl_NV_memory_attachment"))
{
NV_memory_attachment = true;
extensions.Remove("glNV_memory_attachment");
}
if (extensions.Contains("gl_NV_memory_object_sparse"))
{
NV_memory_object_sparse = true;
extensions.Remove("glNV_memory_object_sparse");
}
if (extensions.Contains("gl_NV_mesh_shader"))
{
NV_mesh_shader = true;
extensions.Remove("glNV_mesh_shader");
}
if (extensions.Contains("gl_NV_multisample_coverage"))
{
NV_multisample_coverage = true;
extensions.Remove("glNV_multisample_coverage");
}
if (extensions.Contains("gl_NV_multisample_filter_hint"))
{
NV_multisample_filter_hint = true;
extensions.Remove("glNV_multisample_filter_hint");
}
if (extensions.Contains("gl_NV_occlusion_query"))
{
NV_occlusion_query = true;
extensions.Remove("glNV_occlusion_query");
}
if (extensions.Contains("gl_NV_packed_depth_stencil"))
{
NV_packed_depth_stencil = true;
extensions.Remove("glNV_packed_depth_stencil");
}
if (extensions.Contains("gl_NV_parameter_buffer_object"))
{
NV_parameter_buffer_object = true;
extensions.Remove("glNV_parameter_buffer_object");
}
if (extensions.Contains("gl_NV_parameter_buffer_object2"))
{
NV_parameter_buffer_object2 = true;
extensions.Remove("glNV_parameter_buffer_object2");
}
if (extensions.Contains("gl_NV_path_rendering"))
{
NV_path_rendering = true;
extensions.Remove("glNV_path_rendering");
}
if (extensions.Contains("gl_NV_path_rendering_shared_edge"))
{
NV_path_rendering_shared_edge = true;
extensions.Remove("glNV_path_rendering_shared_edge");
}
if (extensions.Contains("gl_NV_pixel_data_range"))
{
NV_pixel_data_range = true;
extensions.Remove("glNV_pixel_data_range");
}
if (extensions.Contains("gl_NV_point_sprite"))
{
NV_point_sprite = true;
extensions.Remove("glNV_point_sprite");
}
if (extensions.Contains("gl_NV_present_video"))
{
NV_present_video = true;
extensions.Remove("glNV_present_video");
}
if (extensions.Contains("gl_NV_primitive_restart"))
{
NV_primitive_restart = true;
extensions.Remove("glNV_primitive_restart");
}
if (extensions.Contains("gl_NV_primitive_shading_rate"))
{
NV_primitive_shading_rate = true;
extensions.Remove("glNV_primitive_shading_rate");
}
if (extensions.Contains("gl_NV_query_resource"))
{
NV_query_resource = true;
extensions.Remove("glNV_query_resource");
}
if (extensions.Contains("gl_NV_query_resource_tag"))
{
NV_query_resource_tag = true;
extensions.Remove("glNV_query_resource_tag");
}
if (extensions.Contains("gl_NV_register_combiners"))
{
NV_register_combiners = true;
extensions.Remove("glNV_register_combiners");
}
if (extensions.Contains("gl_NV_register_combiners2"))
{
NV_register_combiners2 = true;
extensions.Remove("glNV_register_combiners2");
}
if (extensions.Contains("gl_NV_representative_fragment_test"))
{
NV_representative_fragment_test = true;
extensions.Remove("glNV_representative_fragment_test");
}
if (extensions.Contains("gl_NV_robustness_video_memory_purge"))
{
NV_robustness_video_memory_purge = true;
extensions.Remove("glNV_robustness_video_memory_purge");
}
if (extensions.Contains("gl_NV_sample_locations"))
{
NV_sample_locations = true;
extensions.Remove("glNV_sample_locations");
}
if (extensions.Contains("gl_NV_sample_mask_override_coverage"))
{
NV_sample_mask_override_coverage = true;
extensions.Remove("glNV_sample_mask_override_coverage");
}
if (extensions.Contains("gl_NV_scissor_exclusive"))
{
NV_scissor_exclusive = true;
extensions.Remove("glNV_scissor_exclusive");
}
if (extensions.Contains("gl_NV_shader_atomic_counters"))
{
NV_shader_atomic_counters = true;
extensions.Remove("glNV_shader_atomic_counters");
}
if (extensions.Contains("gl_NV_shader_atomic_float"))
{
NV_shader_atomic_float = true;
extensions.Remove("glNV_shader_atomic_float");
}
if (extensions.Contains("gl_NV_shader_atomic_float64"))
{
NV_shader_atomic_float64 = true;
extensions.Remove("glNV_shader_atomic_float64");
}
if (extensions.Contains("gl_NV_shader_atomic_fp16_vector"))
{
NV_shader_atomic_fp16_vector = true;
extensions.Remove("glNV_shader_atomic_fp16_vector");
}
if (extensions.Contains("gl_NV_shader_atomic_int64"))
{
NV_shader_atomic_int64 = true;
extensions.Remove("glNV_shader_atomic_int64");
}
if (extensions.Contains("gl_NV_shader_buffer_load"))
{
NV_shader_buffer_load = true;
extensions.Remove("glNV_shader_buffer_load");
}
if (extensions.Contains("gl_NV_shader_buffer_store"))
{
NV_shader_buffer_store = true;
extensions.Remove("glNV_shader_buffer_store");
}
if (extensions.Contains("gl_NV_shader_storage_buffer_object"))
{
NV_shader_storage_buffer_object = true;
extensions.Remove("glNV_shader_storage_buffer_object");
}
if (extensions.Contains("gl_NV_shader_subgroup_partitioned"))
{
NV_shader_subgroup_partitioned = true;
extensions.Remove("glNV_shader_subgroup_partitioned");
}
if (extensions.Contains("gl_NV_shader_texture_footprint"))
{
NV_shader_texture_footprint = true;
extensions.Remove("glNV_shader_texture_footprint");
}
if (extensions.Contains("gl_NV_shader_thread_group"))
{
NV_shader_thread_group = true;
extensions.Remove("glNV_shader_thread_group");
}
if (extensions.Contains("gl_NV_shader_thread_shuffle"))
{
NV_shader_thread_shuffle = true;
extensions.Remove("glNV_shader_thread_shuffle");
}
if (extensions.Contains("gl_NV_shading_rate_image"))
{
NV_shading_rate_image = true;
extensions.Remove("glNV_shading_rate_image");
}
if (extensions.Contains("gl_NV_stereo_view_rendering"))
{
NV_stereo_view_rendering = true;
extensions.Remove("glNV_stereo_view_rendering");
}
if (extensions.Contains("gl_NV_tessellation_program5"))
{
NV_tessellation_program5 = true;
extensions.Remove("glNV_tessellation_program5");
}
if (extensions.Contains("gl_NV_texgen_emboss"))
{
NV_texgen_emboss = true;
extensions.Remove("glNV_texgen_emboss");
}
if (extensions.Contains("gl_NV_texgen_reflection"))
{
NV_texgen_reflection = true;
extensions.Remove("glNV_texgen_reflection");
}
if (extensions.Contains("gl_NV_texture_barrier"))
{
NV_texture_barrier = true;
extensions.Remove("glNV_texture_barrier");
}
if (extensions.Contains("gl_NV_texture_compression_vtc"))
{
NV_texture_compression_vtc = true;
extensions.Remove("glNV_texture_compression_vtc");
}
if (extensions.Contains("gl_NV_texture_env_combine4"))
{
NV_texture_env_combine4 = true;
extensions.Remove("glNV_texture_env_combine4");
}
if (extensions.Contains("gl_NV_texture_expand_normal"))
{
NV_texture_expand_normal = true;
extensions.Remove("glNV_texture_expand_normal");
}
if (extensions.Contains("gl_NV_texture_multisample"))
{
NV_texture_multisample = true;
extensions.Remove("glNV_texture_multisample");
}
if (extensions.Contains("gl_NV_texture_rectangle"))
{
NV_texture_rectangle = true;
extensions.Remove("glNV_texture_rectangle");
}
if (extensions.Contains("gl_NV_texture_rectangle_compressed"))
{
NV_texture_rectangle_compressed = true;
extensions.Remove("glNV_texture_rectangle_compressed");
}
if (extensions.Contains("gl_NV_texture_shader"))
{
NV_texture_shader = true;
extensions.Remove("glNV_texture_shader");
}
if (extensions.Contains("gl_NV_texture_shader2"))
{
NV_texture_shader2 = true;
extensions.Remove("glNV_texture_shader2");
}
if (extensions.Contains("gl_NV_texture_shader3"))
{
NV_texture_shader3 = true;
extensions.Remove("glNV_texture_shader3");
}
if (extensions.Contains("gl_NV_timeline_semaphore"))
{
NV_timeline_semaphore = true;
extensions.Remove("glNV_timeline_semaphore");
}
if (extensions.Contains("gl_NV_transform_feedback"))
{
NV_transform_feedback = true;
extensions.Remove("glNV_transform_feedback");
}
if (extensions.Contains("gl_NV_transform_feedback2"))
{
NV_transform_feedback2 = true;
extensions.Remove("glNV_transform_feedback2");
}
if (extensions.Contains("gl_NV_uniform_buffer_std430_layout"))
{
NV_uniform_buffer_std430_layout = true;
extensions.Remove("glNV_uniform_buffer_std430_layout");
}
if (extensions.Contains("gl_NV_uniform_buffer_unified_memory"))
{
NV_uniform_buffer_unified_memory = true;
extensions.Remove("glNV_uniform_buffer_unified_memory");
}
if (extensions.Contains("gl_NV_vdpau_interop"))
{
NV_vdpau_interop = true;
extensions.Remove("glNV_vdpau_interop");
}
if (extensions.Contains("gl_NV_vdpau_interop2"))
{
NV_vdpau_interop2 = true;
extensions.Remove("glNV_vdpau_interop2");
}
if (extensions.Contains("gl_NV_vertex_array_range"))
{
NV_vertex_array_range = true;
extensions.Remove("glNV_vertex_array_range");
}
if (extensions.Contains("gl_NV_vertex_array_range2"))
{
NV_vertex_array_range2 = true;
extensions.Remove("glNV_vertex_array_range2");
}
if (extensions.Contains("gl_NV_vertex_attrib_integer_64bit"))
{
NV_vertex_attrib_integer_64bit = true;
extensions.Remove("glNV_vertex_attrib_integer_64bit");
}
if (extensions.Contains("gl_NV_vertex_buffer_unified_memory"))
{
NV_vertex_buffer_unified_memory = true;
extensions.Remove("glNV_vertex_buffer_unified_memory");
}
if (extensions.Contains("gl_NV_vertex_program"))
{
NV_vertex_program = true;
extensions.Remove("glNV_vertex_program");
}
if (extensions.Contains("gl_NV_vertex_program1_1"))
{
NV_vertex_program1_1 = true;
extensions.Remove("glNV_vertex_program1_1");
}
if (extensions.Contains("gl_NV_vertex_program2"))
{
NV_vertex_program2 = true;
extensions.Remove("glNV_vertex_program2");
}
if (extensions.Contains("gl_NV_vertex_program2_option"))
{
NV_vertex_program2_option = true;
extensions.Remove("glNV_vertex_program2_option");
}
if (extensions.Contains("gl_NV_vertex_program3"))
{
NV_vertex_program3 = true;
extensions.Remove("glNV_vertex_program3");
}
if (extensions.Contains("gl_NV_vertex_program4"))
{
NV_vertex_program4 = true;
extensions.Remove("glNV_vertex_program4");
}
if (extensions.Contains("gl_NV_video_capture"))
{
NV_video_capture = true;
extensions.Remove("glNV_video_capture");
}
if (extensions.Contains("gl_NV_viewport_array2"))
{
NV_viewport_array2 = true;
extensions.Remove("glNV_viewport_array2");
}
if (extensions.Contains("gl_NV_viewport_swizzle"))
{
NV_viewport_swizzle = true;
extensions.Remove("glNV_viewport_swizzle");
}
if (extensions.Contains("gl_OES_byte_coordinates"))
{
OES_byte_coordinates = true;
extensions.Remove("glOES_byte_coordinates");
}
if (extensions.Contains("gl_OES_compressed_paletted_texture"))
{
OES_compressed_paletted_texture = true;
extensions.Remove("glOES_compressed_paletted_texture");
}
if (extensions.Contains("gl_OES_fixed_point"))
{
OES_fixed_point = true;
extensions.Remove("glOES_fixed_point");
}
if (extensions.Contains("gl_OES_query_matrix"))
{
OES_query_matrix = true;
extensions.Remove("glOES_query_matrix");
}
if (extensions.Contains("gl_OES_read_format"))
{
OES_read_format = true;
extensions.Remove("glOES_read_format");
}
if (extensions.Contains("gl_OES_single_precision"))
{
OES_single_precision = true;
extensions.Remove("glOES_single_precision");
}
if (extensions.Contains("gl_OML_interlace"))
{
OML_interlace = true;
extensions.Remove("glOML_interlace");
}
if (extensions.Contains("gl_OML_resample"))
{
OML_resample = true;
extensions.Remove("glOML_resample");
}
if (extensions.Contains("gl_OML_subsample"))
{
OML_subsample = true;
extensions.Remove("glOML_subsample");
}
if (extensions.Contains("gl_OVR_multiview"))
{
OVR_multiview = true;
extensions.Remove("glOVR_multiview");
}
if (extensions.Contains("gl_OVR_multiview2"))
{
OVR_multiview2 = true;
extensions.Remove("glOVR_multiview2");
}
if (extensions.Contains("gl_PGI_misc_hints"))
{
PGI_misc_hints = true;
extensions.Remove("glPGI_misc_hints");
}
if (extensions.Contains("gl_PGI_vertex_hints"))
{
PGI_vertex_hints = true;
extensions.Remove("glPGI_vertex_hints");
}
if (extensions.Contains("gl_REND_screen_coordinates"))
{
REND_screen_coordinates = true;
extensions.Remove("glREND_screen_coordinates");
}
if (extensions.Contains("gl_S3_s3tc"))
{
S3_s3tc = true;
extensions.Remove("glS3_s3tc");
}
if (extensions.Contains("gl_SGIS_detail_texture"))
{
SGIS_detail_texture = true;
extensions.Remove("glSGIS_detail_texture");
}
if (extensions.Contains("gl_SGIS_fog_function"))
{
SGIS_fog_function = true;
extensions.Remove("glSGIS_fog_function");
}
if (extensions.Contains("gl_SGIS_generate_mipmap"))
{
SGIS_generate_mipmap = true;
extensions.Remove("glSGIS_generate_mipmap");
}
if (extensions.Contains("gl_SGIS_multisample"))
{
SGIS_multisample = true;
extensions.Remove("glSGIS_multisample");
}
if (extensions.Contains("gl_SGIS_pixel_texture"))
{
SGIS_pixel_texture = true;
extensions.Remove("glSGIS_pixel_texture");
}
if (extensions.Contains("gl_SGIS_point_line_texgen"))
{
SGIS_point_line_texgen = true;
extensions.Remove("glSGIS_point_line_texgen");
}
if (extensions.Contains("gl_SGIS_point_parameters"))
{
SGIS_point_parameters = true;
extensions.Remove("glSGIS_point_parameters");
}
if (extensions.Contains("gl_SGIS_sharpen_texture"))
{
SGIS_sharpen_texture = true;
extensions.Remove("glSGIS_sharpen_texture");
}
if (extensions.Contains("gl_SGIS_texture4D"))
{
SGIS_texture4D = true;
extensions.Remove("glSGIS_texture4D");
}
if (extensions.Contains("gl_SGIS_texture_border_clamp"))
{
SGIS_texture_border_clamp = true;
extensions.Remove("glSGIS_texture_border_clamp");
}
if (extensions.Contains("gl_SGIS_texture_color_mask"))
{
SGIS_texture_color_mask = true;
extensions.Remove("glSGIS_texture_color_mask");
}
if (extensions.Contains("gl_SGIS_texture_edge_clamp"))
{
SGIS_texture_edge_clamp = true;
extensions.Remove("glSGIS_texture_edge_clamp");
}
if (extensions.Contains("gl_SGIS_texture_filter4"))
{
SGIS_texture_filter4 = true;
extensions.Remove("glSGIS_texture_filter4");
}
if (extensions.Contains("gl_SGIS_texture_lod"))
{
SGIS_texture_lod = true;
extensions.Remove("glSGIS_texture_lod");
}
if (extensions.Contains("gl_SGIS_texture_select"))
{
SGIS_texture_select = true;
extensions.Remove("glSGIS_texture_select");
}
if (extensions.Contains("gl_SGIX_async"))
{
SGIX_async = true;
extensions.Remove("glSGIX_async");
}
if (extensions.Contains("gl_SGIX_async_histogram"))
{
SGIX_async_histogram = true;
extensions.Remove("glSGIX_async_histogram");
}
if (extensions.Contains("gl_SGIX_async_pixel"))
{
SGIX_async_pixel = true;
extensions.Remove("glSGIX_async_pixel");
}
if (extensions.Contains("gl_SGIX_blend_alpha_minmax"))
{
SGIX_blend_alpha_minmax = true;
extensions.Remove("glSGIX_blend_alpha_minmax");
}
if (extensions.Contains("gl_SGIX_calligraphic_fragment"))
{
SGIX_calligraphic_fragment = true;
extensions.Remove("glSGIX_calligraphic_fragment");
}
if (extensions.Contains("gl_SGIX_clipmap"))
{
SGIX_clipmap = true;
extensions.Remove("glSGIX_clipmap");
}
if (extensions.Contains("gl_SGIX_convolution_accuracy"))
{
SGIX_convolution_accuracy = true;
extensions.Remove("glSGIX_convolution_accuracy");
}
if (extensions.Contains("gl_SGIX_depth_pass_instrument"))
{
SGIX_depth_pass_instrument = true;
extensions.Remove("glSGIX_depth_pass_instrument");
}
if (extensions.Contains("gl_SGIX_depth_texture"))
{
SGIX_depth_texture = true;
extensions.Remove("glSGIX_depth_texture");
}
if (extensions.Contains("gl_SGIX_flush_raster"))
{
SGIX_flush_raster = true;
extensions.Remove("glSGIX_flush_raster");
}
if (extensions.Contains("gl_SGIX_fog_offset"))
{
SGIX_fog_offset = true;
extensions.Remove("glSGIX_fog_offset");
}
if (extensions.Contains("gl_SGIX_fragment_lighting"))
{
SGIX_fragment_lighting = true;
extensions.Remove("glSGIX_fragment_lighting");
}
if (extensions.Contains("gl_SGIX_framezoom"))
{
SGIX_framezoom = true;
extensions.Remove("glSGIX_framezoom");
}
if (extensions.Contains("gl_SGIX_igloo_interface"))
{
SGIX_igloo_interface = true;
extensions.Remove("glSGIX_igloo_interface");
}
if (extensions.Contains("gl_SGIX_instruments"))
{
SGIX_instruments = true;
extensions.Remove("glSGIX_instruments");
}
if (extensions.Contains("gl_SGIX_interlace"))
{
SGIX_interlace = true;
extensions.Remove("glSGIX_interlace");
}
if (extensions.Contains("gl_SGIX_ir_instrument1"))
{
SGIX_ir_instrument1 = true;
extensions.Remove("glSGIX_ir_instrument1");
}
if (extensions.Contains("gl_SGIX_list_priority"))
{
SGIX_list_priority = true;
extensions.Remove("glSGIX_list_priority");
}
if (extensions.Contains("gl_SGIX_pixel_texture"))
{
SGIX_pixel_texture = true;
extensions.Remove("glSGIX_pixel_texture");
}
if (extensions.Contains("gl_SGIX_pixel_tiles"))
{
SGIX_pixel_tiles = true;
extensions.Remove("glSGIX_pixel_tiles");
}
if (extensions.Contains("gl_SGIX_polynomial_ffd"))
{
SGIX_polynomial_ffd = true;
extensions.Remove("glSGIX_polynomial_ffd");
}
if (extensions.Contains("gl_SGIX_reference_plane"))
{
SGIX_reference_plane = true;
extensions.Remove("glSGIX_reference_plane");
}
if (extensions.Contains("gl_SGIX_resample"))
{
SGIX_resample = true;
extensions.Remove("glSGIX_resample");
}
if (extensions.Contains("gl_SGIX_scalebias_hint"))
{
SGIX_scalebias_hint = true;
extensions.Remove("glSGIX_scalebias_hint");
}
if (extensions.Contains("gl_SGIX_shadow"))
{
SGIX_shadow = true;
extensions.Remove("glSGIX_shadow");
}
if (extensions.Contains("gl_SGIX_shadow_ambient"))
{
SGIX_shadow_ambient = true;
extensions.Remove("glSGIX_shadow_ambient");
}
if (extensions.Contains("gl_SGIX_sprite"))
{
SGIX_sprite = true;
extensions.Remove("glSGIX_sprite");
}
if (extensions.Contains("gl_SGIX_subsample"))
{
SGIX_subsample = true;
extensions.Remove("glSGIX_subsample");
}
if (extensions.Contains("gl_SGIX_tag_sample_buffer"))
{
SGIX_tag_sample_buffer = true;
extensions.Remove("glSGIX_tag_sample_buffer");
}
if (extensions.Contains("gl_SGIX_texture_add_env"))
{
SGIX_texture_add_env = true;
extensions.Remove("glSGIX_texture_add_env");
}
if (extensions.Contains("gl_SGIX_texture_coordinate_clamp"))
{
SGIX_texture_coordinate_clamp = true;
extensions.Remove("glSGIX_texture_coordinate_clamp");
}
if (extensions.Contains("gl_SGIX_texture_lod_bias"))
{
SGIX_texture_lod_bias = true;
extensions.Remove("glSGIX_texture_lod_bias");
}
if (extensions.Contains("gl_SGIX_texture_multi_buffer"))
{
SGIX_texture_multi_buffer = true;
extensions.Remove("glSGIX_texture_multi_buffer");
}
if (extensions.Contains("gl_SGIX_texture_scale_bias"))
{
SGIX_texture_scale_bias = true;
extensions.Remove("glSGIX_texture_scale_bias");
}
if (extensions.Contains("gl_SGIX_vertex_preclip"))
{
SGIX_vertex_preclip = true;
extensions.Remove("glSGIX_vertex_preclip");
}
if (extensions.Contains("gl_SGIX_ycrcb"))
{
SGIX_ycrcb = true;
extensions.Remove("glSGIX_ycrcb");
}
if (extensions.Contains("gl_SGIX_ycrcb_subsample"))
{
SGIX_ycrcb_subsample = true;
extensions.Remove("glSGIX_ycrcb_subsample");
}
if (extensions.Contains("gl_SGIX_ycrcba"))
{
SGIX_ycrcba = true;
extensions.Remove("glSGIX_ycrcba");
}
if (extensions.Contains("gl_SGI_color_matrix"))
{
SGI_color_matrix = true;
extensions.Remove("glSGI_color_matrix");
}
if (extensions.Contains("gl_SGI_color_table"))
{
SGI_color_table = true;
extensions.Remove("glSGI_color_table");
}
if (extensions.Contains("gl_SGI_texture_color_table"))
{
SGI_texture_color_table = true;
extensions.Remove("glSGI_texture_color_table");
}
if (extensions.Contains("gl_SUNX_constant_data"))
{
SUNX_constant_data = true;
extensions.Remove("glSUNX_constant_data");
}
if (extensions.Contains("gl_SUN_convolution_border_modes"))
{
SUN_convolution_border_modes = true;
extensions.Remove("glSUN_convolution_border_modes");
}
if (extensions.Contains("gl_SUN_global_alpha"))
{
SUN_global_alpha = true;
extensions.Remove("glSUN_global_alpha");
}
if (extensions.Contains("gl_SUN_mesh_array"))
{
SUN_mesh_array = true;
extensions.Remove("glSUN_mesh_array");
}
if (extensions.Contains("gl_SUN_slice_accum"))
{
SUN_slice_accum = true;
extensions.Remove("glSUN_slice_accum");
}
if (extensions.Contains("gl_SUN_triangle_list"))
{
SUN_triangle_list = true;
extensions.Remove("glSUN_triangle_list");
}
if (extensions.Contains("gl_SUN_vertex"))
{
SUN_vertex = true;
extensions.Remove("glSUN_vertex");
}
if (extensions.Contains("gl_WIN_phong_shading"))
{
WIN_phong_shading = true;
extensions.Remove("glWIN_phong_shading");
}
if (extensions.Contains("gl_WIN_specular_fog"))
{
WIN_specular_fog = true;
extensions.Remove("glWIN_specular_fog");
}
#endregion checkGLextensions
}
internal static void CheckCoreVersion(int majorVersion, int minorVersion)
{
if (majorVersion < 3) {
throw new InvalidOperationException(
"StgSharp does not support OpenGL immediate mode.");
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 0)))
{
core10 = true;
} else
{
goto log;
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 1)))
{
core11 = true;
} else
{
goto log;
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 2)))
{
core12 = true;
} else
{
goto log;
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 3)))
{
core13 = true;
} else
{
goto log;
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 4)))
{
core14 = true;
} else
{
goto log;
}
if ((majorVersion >= 1) || ((majorVersion == 1) && (minorVersion == 5)))
{
core15 = true;
} else
{
goto log;
}
if ((majorVersion >= 2) || ((majorVersion == 2) && (minorVersion == 0)))
{
core20 = true;
} else
{
goto log;
}
if ((majorVersion >= 2) || ((majorVersion == 2) && (minorVersion == 1)))
{
core21 = true;
} else
{
goto log;
}
if ((majorVersion >= 3) || ((majorVersion == 3) && (minorVersion == 0)))
{
core30 = true;
} else
{
goto log;
}
if ((majorVersion >= 3) || ((majorVersion == 3) && (minorVersion == 1)))
{
core31 = true;
} else
{
goto log;
}
if ((majorVersion >= 3) || ((majorVersion == 3) && (minorVersion == 2)))
{
core32 = true;
} else
{
goto log;
}
if ((majorVersion >= 3) || ((majorVersion == 3) && (minorVersion == 3)))
{
core33 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 0)))
{
core40 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 1)))
{
core41 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 2)))
{
core42 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 3)))
{
core43 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 4)))
{
core44 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 5)))
{
core45 = true;
} else
{
goto log;
}
if ((majorVersion >= 4) || ((majorVersion == 4) && (minorVersion == 6)))
{
core46 = true;
} else
{
goto log;
}
log:
{
InternalIO.InternalWriteLog("Find core OpenGL version.", LogType.Info);
return;
}
}
internal static unsafe string GetExtensions(this OpenglContext context)
{
if (context.glGetString == null) {
return string.Empty;
}
return Marshal.PtrToStringAnsi(context.glGetString(glExtension));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static T internalLoadAPI<T>(IntPtr ptr) where T: Delegate
{
try
{
if (ptr == IntPtr.Zero) {
return null;
}
T func = Marshal.GetDelegateForFunctionPointer<T>(ptr);
return func;
}
catch (Exception ex)
{
InternalIO.InternalWriteLog(
$"{$"Failed to convert the api {typeof(T).Name}.\n"}{ex.Message}",
LogType.Warning);
return default;
}
}
internal static unsafe void LoadGLcore10(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core10)
{
InternalIO.InternalAppendLog("The core version 1.0 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBlendFunc = (delegate*<uint, uint, void>)load("glBlendFunc");
contextPtr->glClear = (delegate*<uint, void>)load("glClear");
contextPtr->glClearColor = (delegate*<float, float, float, float, void>)load(
"glClearColor");
contextPtr->glClearDepth = (delegate*<double, void>)load("glClearDepth");
contextPtr->glClearStencil = (delegate*<int, void>)load("glClearStencil");
contextPtr->glColorMask = (delegate*<bool, bool, bool, bool, void>)load(
"glColorMask");
contextPtr->glCullFace = (delegate*<uint, void>)load("glCullFace");
contextPtr->glDepthFunc = (delegate*<uint, void>)load("glDepthFunc");
contextPtr->glDepthMask = (delegate*<bool, void>)load("glDepthMask");
contextPtr->glDepthRange = (delegate*<double, double, void>)load("glDepthRange");
contextPtr->glDisable = (delegate*<uint, void>)load("glDisable");
contextPtr->glDrawBuffer = (delegate*<uint, void>)load("glDrawBuffer");
contextPtr->glEnable = (delegate*<uint, void>)load("glEnable");
contextPtr->glFinish = (delegate*<void>)load("glFinish");
contextPtr->glFlush = (delegate*<void>)load("glFlush");
contextPtr->glFrontFace = (delegate*<uint, void>)load("glFrontFace");
contextPtr->glGetBooleanv = (delegate*<uint, bool*, void>)load("glGetBooleanv");
contextPtr->glGetDoublev = (delegate*<uint, double*, void>)load("glGetDoublev");
contextPtr->glGetError = (delegate*<uint>)load("glGetError");
contextPtr->glGetFloatv = (delegate*<uint, float*, void>)load("glGetFloatv");
contextPtr->glGetIntegerv = (delegate*<uint, int*, void>)load("glGetIntegerv");
contextPtr->glGetString = (delegate*<uint, IntPtr>)load("glGetString");
contextPtr->glGetTexImage = (delegate*<uint, int, uint, uint, void*, void>)load(
"glGetTexImage");
contextPtr->glGetTexLevelParameterfv = (delegate*<uint, int, uint, float*, void>)load(
"glGetTexLevelParameterfv");
contextPtr->glGetTexLevelParameteriv = (delegate*<uint, int, uint, int*, void>)load(
"glGetTexLevelParameteriv");
contextPtr->glGetTexParameterfv = (delegate*<uint, uint, float*, void>)load(
"glGetTexParameterfv");
contextPtr->glGetTexParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetTexParameteriv");
contextPtr->glHint = (delegate*<uint, uint, void>)load("glHint");
contextPtr->glIsEnabled = (delegate*<uint, bool>)load("glIsEnabled");
contextPtr->glLineWidth = (delegate*<float, void>)load("glLineWidth");
contextPtr->glLogicOp = (delegate*<uint, void>)load("glLogicOp");
contextPtr->glPixelStoref = (delegate*<uint, float, void>)load("glPixelStoref");
contextPtr->glPixelStorei = (delegate*<uint, int, void>)load("glPixelStorei");
contextPtr->glPointSize = (delegate*<float, void>)load("glPointSize");
contextPtr->glPolygonMode = (delegate*<uint, uint, void>)load("glPolygonMode");
contextPtr->glReadBuffer = (delegate*<uint, void>)load("glReadBuffer");
contextPtr->glReadPixels = (delegate*<int, int, int, int, uint, uint, void*, void>)load(
"glReadPixels");
contextPtr->glScissor = (delegate*<int, int, uint, uint, void>)load("glScissor");
contextPtr->glStencilFunc = (delegate*<uint, int, uint, void>)load("glStencilFunc");
contextPtr->glStencilMask = (delegate*<uint, void>)load("glStencilMask");
contextPtr->glStencilOp = (delegate*<uint, uint, uint, void>)load("glStencilOp");
contextPtr->glTexImage1D = (delegate*<uint, int, int, uint, int, uint, uint, void*, void>)load(
"glTexImage1D");
contextPtr->glTexImage2D = (delegate*<uint, int, uint, uint, uint, int, uint, uint, void*, void>)load(
"glTexImage2D");
contextPtr->glTexParameterf = (delegate*<uint, uint, float, void>)load(
"glTexParameterf");
contextPtr->glTexParameterfv = (delegate*<uint, uint, float*, void>)load(
"glTexParameterfv");
contextPtr->glTexParameteri = (delegate*<uint, uint, int, void>)load(
"glTexParameteri");
contextPtr->glTexParameteriv = (delegate*<uint, uint, int*, void>)load(
"glTexParameteriv");
contextPtr->glViewport = (delegate*<int, int, uint, uint, void>)load("glViewport");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.0 APIs");
}
internal static unsafe void LoadGLcore11(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core11)
{
InternalIO.InternalAppendLog("The core version 1.1 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindTexture = (delegate*<uint, uint, void>)load("glBindTexture");
contextPtr->glCopyTexImage1D = (delegate*<uint, int, uint, int, int, uint, int, void>)load(
"glCopyTexImage1D");
contextPtr->glCopyTexImage2D = (delegate*<uint, int, uint, int, int, uint, uint, int, void>)load(
"glCopyTexImage2D");
contextPtr->glCopyTexSubImage1D = (delegate*<uint, int, int, int, int, uint, void>)load(
"glCopyTexSubImage1D");
contextPtr->glCopyTexSubImage2D = (delegate*<uint, int, int, int, int, int, uint, uint, void>)load(
"glCopyTexSubImage2D");
contextPtr->glDeleteTextures = (delegate*<uint, uint*, void>)load(
"glDeleteTextures");
contextPtr->glDrawArrays = (delegate*<uint, int, uint, void>)load("glDrawArrays");
contextPtr->glDrawElements = (delegate*<uint, uint, uint, void*, void>)load(
"glDrawElements");
contextPtr->glGenTextures = (delegate*<int, uint*, void>)load("glGenTextures");
contextPtr->glGetPointerv = (delegate*<uint, void**, void>)load("glGetPointerv");
contextPtr->glIsTexture = (delegate*<uint, bool>)load("glIsTexture");
contextPtr->glPolygonOffset = (delegate*<float, float, void>)load("glPolygonOffset");
contextPtr->glTexSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
"glTexSubImage1D");
contextPtr->glTexSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
"glTexSubImage2D");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.1 APIs");
}
internal static unsafe void LoadGLcore12(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core12)
{
InternalIO.InternalAppendLog("The core version 1.2 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glCopyTexSubImage3D = (delegate*<uint, int, int, int, int, int, int, uint, uint, void>)load(
"glCopyTexSubImage3D");
contextPtr->glDrawRangeElements = (delegate*<uint, uint, uint, uint, uint, void*, void>)load(
"glDrawRangeElements");
contextPtr->glTexImage3D = (delegate*<uint, int, int, uint, uint, uint, int, uint, uint, void*, void>)load(
"glTexImage3D");
contextPtr->glTexSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
"glTexSubImage3D");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.2 APIs");
}
internal static unsafe void LoadGLcore13(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core13)
{
InternalIO.InternalAppendLog("The core version 1.3 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glActiveTexture = (delegate*<uint, void>)load("glActiveTexture");
contextPtr->glCompressedTexImage1D = (delegate*<uint, int, uint, uint, int, uint, void*, void>)load(
"glCompressedTexImage1D");
contextPtr->glCompressedTexImage2D = (delegate*<uint, int, uint, uint, uint, int, uint, void*, void>)load(
"glCompressedTexImage2D");
contextPtr->glCompressedTexImage3D = (delegate*<uint, int, uint, uint, uint, uint, int, uint, void*, void>)load(
"glCompressedTexImage3D");
contextPtr->glCompressedTexSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
"glCompressedTexSubImage1D");
contextPtr->glCompressedTexSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
"glCompressedTexSubImage2D");
contextPtr->glCompressedTexSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
"glCompressedTexSubImage3D");
contextPtr->glGetCompressedTexImage = (delegate*<uint, int, void*, void>)load(
"glGetCompressedTexImage");
contextPtr->glSampleCoverage = (delegate*<float, bool, void>)load(
"glSampleCoverage");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.3 APIs");
}
internal static unsafe void LoadGLcore14(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core14)
{
InternalIO.InternalAppendLog("The core version 1.4 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBlendColor = (delegate*<float, float, float, float, void>)load(
"glBlendColor");
contextPtr->glBlendEquation = (delegate*<uint, void>)load("glBlendEquation");
contextPtr->glBlendFuncSeparate = (delegate*<uint, uint, uint, uint, void>)load(
"glBlendFuncSeparate");
contextPtr->glMultiDrawArrays = (delegate*<uint, int*, uint*, uint, void>)load(
"glMultiDrawArrays");
contextPtr->glMultiDrawElements = (delegate*<uint, uint*, uint, void*, void**, uint, void>)load(
"glMultiDrawElements");
contextPtr->glPointParameterf = (delegate*<uint, float, void>)load(
"glPointParameterf");
contextPtr->glPointParameterfv = (delegate*<uint, float*, void>)load(
"glPointParameterfv");
contextPtr->glPointParameteri = (delegate*<uint, int, void>)load(
"glPointParameteri");
contextPtr->glPointParameteriv = (delegate*<uint, int*, void>)load(
"glPointParameteriv");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.4 APIs");
}
internal static unsafe void LoadGLcore15(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core15)
{
InternalIO.InternalAppendLog("The core version 1.5 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBeginQuery = (delegate*<uint, uint, void>)load("glBeginQuery");
contextPtr->glBindBuffer = (delegate*<uint, uint, void>)load("glBindBuffer");
contextPtr->glBufferData = (delegate*<uint, IntPtr, IntPtr, uint, void>)load(
"glBufferData");
contextPtr->glBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
"glBufferSubData");
contextPtr->glDeleteBuffers = (delegate*<int, uint*, void>)load("glDeleteBuffers");
contextPtr->glDeleteQueries = (delegate*<uint, uint*, void>)load("glDeleteQueries");
contextPtr->glEndQuery = (delegate*<uint, void>)load("glEndQuery");
contextPtr->glGenBuffers = (delegate*<int, uint*, void>)load("glGenBuffers");
contextPtr->glGenQueries = (delegate*<uint, uint*, void>)load("glGenQueries");
contextPtr->glGetBufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetBufferParameteriv");
contextPtr->glGetBufferPointerv = (delegate*<uint, uint, void**, void>)load(
"glGetBufferPointerv");
contextPtr->glGetBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
"glGetBufferSubData");
contextPtr->glGetQueryObjectiv = (delegate*<uint, uint, int*, void>)load(
"glGetQueryObjectiv");
contextPtr->glGetQueryObjectuiv = (delegate*<uint, uint, uint*, void>)load(
"glGetQueryObjectuiv");
contextPtr->glGetQueryiv = (delegate*<uint, uint, int*, void>)load("glGetQueryiv");
contextPtr->glIsBuffer = (delegate*<uint, bool>)load("glIsBuffer");
contextPtr->glIsQuery = (delegate*<uint, bool>)load("glIsQuery");
contextPtr->glMapBuffer = (delegate*<uint, uint, void*>)load("glMapBuffer");
contextPtr->glUnmapBuffer = (delegate*<uint, bool>)load("glUnmapBuffer");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 1.5 APIs");
}
internal static unsafe void LoadGLcore20(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core20)
{
InternalIO.InternalAppendLog("The core version 2.0 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glAttachShader = (delegate*<uint, uint, void>)load("glAttachShader");
contextPtr->glBindAttribLocation = (delegate*<uint, uint, byte*, void>)load(
"glBindAttribLocation");
contextPtr->glBlendEquationSeparate = (delegate*<uint, uint, void>)load(
"glBlendEquationSeparate");
contextPtr->glCompileShader = (delegate*<uint, void>)load("glCompileShader");
contextPtr->glCreateProgram = (delegate*<uint>)load("glCreateProgram");
contextPtr->glCreateShader = (delegate*<uint, uint>)load("glCreateShader");
contextPtr->glDeleteProgram = (delegate*<uint, void>)load("glDeleteProgram");
contextPtr->glDeleteShader = (delegate*<uint, void>)load("glDeleteShader");
contextPtr->glDetachShader = (delegate*<uint, uint, void>)load("glDetachShader");
contextPtr->glDisableVertexAttribArray = (delegate*<uint, void>)load(
"glDisableVertexAttribArray");
contextPtr->glDrawBuffers = (delegate*<uint, uint*, void>)load("glDrawBuffers");
contextPtr->glEnableVertexAttribArray = (delegate*<uint, void>)load(
"glEnableVertexAttribArray");
contextPtr->glGetActiveAttrib = (delegate*<uint, uint, uint, uint*, int*, uint*, byte*, void>)load(
"glGetActiveAttrib");
contextPtr->glGetActiveUniform = (delegate*<uint, uint, uint, uint*, int*, uint*, byte*, void>)load(
"glGetActiveUniform");
contextPtr->glGetAttachedShaders = (delegate*<uint, uint, uint*, uint*, void>)load(
"glGetAttachedShaders");
contextPtr->glGetAttribLocation = (delegate*<uint, byte*, int>)load(
"glGetAttribLocation");
contextPtr->glGetProgramInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
"glGetProgramInfoLog");
contextPtr->glGetProgramiv = (delegate*<uint, uint, int*, void>)load(
"glGetProgramiv");
contextPtr->glGetShaderInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
"glGetShaderInfoLog");
contextPtr->glGetShaderSource = (delegate*<uint, uint, uint*, byte*, void>)load(
"glGetShaderSource");
contextPtr->glGetShaderiv = (delegate*<uint, uint, int*, void>)load("glGetShaderiv");
contextPtr->glGetUniformLocation = (delegate*<uint, byte*, int>)load(
"glGetUniformLocation");
contextPtr->glGetUniformfv = (delegate*<uint, int, float*, void>)load(
"glGetUniformfv");
contextPtr->glGetUniformiv = (delegate*<uint, int, int*, void>)load(
"glGetUniformiv");
contextPtr->glGetVertexAttribPointerv = (delegate*<uint, uint, void**, void>)load(
"glGetVertexAttribPointerv");
contextPtr->glGetVertexAttribdv = (delegate*<uint, uint, double*, void>)load(
"glGetVertexAttribdv");
contextPtr->glGetVertexAttribfv = (delegate*<uint, uint, float*, void>)load(
"glGetVertexAttribfv");
contextPtr->glGetVertexAttribiv = (delegate*<uint, uint, int*, void>)load(
"glGetVertexAttribiv");
contextPtr->glIsProgram = (delegate*<uint, bool>)load("glIsProgram");
contextPtr->glIsShader = (delegate*<uint, bool>)load("glIsShader");
contextPtr->glLinkProgram = (delegate*<uint, void>)load("glLinkProgram");
contextPtr->glShaderSource = (delegate* unmanaged[Stdcall]<uint, uint, byte**, void*, void>)load(
"glShaderSource");
contextPtr->glStencilFuncSeparate = (delegate*<uint, uint, int, uint, void>)load(
"glStencilFuncSeparate");
contextPtr->glStencilMaskSeparate = (delegate*<uint, uint, void>)load(
"glStencilMaskSeparate");
contextPtr->glStencilOpSeparate = (delegate*<uint, uint, uint, uint, void>)load(
"glStencilOpSeparate");
contextPtr->glUniform1f = (delegate*<int, float, void>)load("glUniform1f");
contextPtr->glUniform1fv = (delegate*<int, uint, M128*, void>)load("glUniform1fv");
contextPtr->glUniform1i = (delegate*<int, int, void>)load("glUniform1i");
contextPtr->glUniform1iv = (delegate*<int, uint, int*, void>)load("glUniform1iv");
contextPtr->glUniform2f = (delegate*<int, float, float, void>)load("glUniform2f");
contextPtr->glUniform2fv = (delegate*<int, uint, float*, void>)load("glUniform2fv");
contextPtr->glUniform2i = (delegate*<int, int, int, void>)load("glUniform2i");
contextPtr->glUniform2iv = (delegate*<int, uint, int*, void>)load("glUniform2iv");
contextPtr->glUniform3f = (delegate*<int, float, float, float, void>)load(
"glUniform3f");
contextPtr->glUniform3fv = (delegate*<int, uint, float*, void>)load("glUniform3fv");
contextPtr->glUniform3i = (delegate*<int, int, int, int, void>)load("glUniform3i");
contextPtr->glUniform3iv = (delegate*<int, uint, int*, void>)load("glUniform3iv");
contextPtr->glUniform4f = (delegate*<int, float, float, float, float, void>)load(
"glUniform4f");
contextPtr->glUniform4fv = (delegate*<int, uint, float*, void>)load("glUniform4fv");
contextPtr->glUniform4i = (delegate*<int, int, int, int, int, void>)load(
"glUniform4i");
contextPtr->glUniform4iv = (delegate*<int, uint, int*, void>)load("glUniform4iv");
contextPtr->glUniformMatrix2fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix2fv");
contextPtr->glUniformMatrix3fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix3fv");
contextPtr->glUniformMatrix4fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix4fv");
contextPtr->glUseProgram = (delegate*<uint, void>)load("glUseProgram");
contextPtr->glValidateProgram = (delegate*<uint, void>)load("glValidateProgram");
contextPtr->glVertexAttrib1d = (delegate*<uint, double, void>)load(
"glVertexAttrib1d");
contextPtr->glVertexAttrib1dv = (delegate*<uint, double*, void>)load(
"glVertexAttrib1dv");
contextPtr->glVertexAttrib1f = (delegate*<uint, float, void>)load(
"glVertexAttrib1f");
contextPtr->glVertexAttrib1fv = (delegate*<uint, float*, void>)load(
"glVertexAttrib1fv");
contextPtr->glVertexAttrib1s = (delegate*<uint, short, void>)load(
"glVertexAttrib1s");
contextPtr->glVertexAttrib1sv = (delegate*<uint, short*, void>)load(
"glVertexAttrib1sv");
contextPtr->glVertexAttrib2d = (delegate*<uint, double, double, void>)load(
"glVertexAttrib2d");
contextPtr->glVertexAttrib2dv = (delegate*<uint, double*, void>)load(
"glVertexAttrib2dv");
contextPtr->glVertexAttrib2f = (delegate*<uint, float, float, void>)load(
"glVertexAttrib2f");
contextPtr->glVertexAttrib2fv = (delegate*<uint, float*, void>)load(
"glVertexAttrib2fv");
contextPtr->glVertexAttrib2s = (delegate*<uint, short, short, void>)load(
"glVertexAttrib2s");
contextPtr->glVertexAttrib2sv = (delegate*<uint, short*, void>)load(
"glVertexAttrib2sv");
contextPtr->glVertexAttrib3d = (delegate*<uint, double, double, double, void>)load(
"glVertexAttrib3d");
contextPtr->glVertexAttrib3dv = (delegate*<uint, double*, void>)load(
"glVertexAttrib3dv");
contextPtr->glVertexAttrib3f = (delegate*<uint, float, float, float, void>)load(
"glVertexAttrib3f");
contextPtr->glVertexAttrib3fv = (delegate*<uint, float*, void>)load(
"glVertexAttrib3fv");
contextPtr->glVertexAttrib3s = (delegate*<uint, short, short, short, void>)load(
"glVertexAttrib3s");
contextPtr->glVertexAttrib3sv = (delegate*<uint, short*, void>)load(
"glVertexAttrib3sv");
contextPtr->glVertexAttrib4Nbv = (delegate*<uint, sbyte*, void>)load(
"glVertexAttrib4Nbv");
contextPtr->glVertexAttrib4Niv = (delegate*<uint, int*, void>)load(
"glVertexAttrib4Niv");
contextPtr->glVertexAttrib4Nsv = (delegate*<uint, short*, void>)load(
"glVertexAttrib4Nsv");
contextPtr->glVertexAttrib4Nub = (delegate*<uint, byte, byte, byte, byte, void>)load(
"glVertexAttrib4Nub");
contextPtr->glVertexAttrib4Nubv = (delegate*<uint, byte*, void>)load(
"glVertexAttrib4Nubv");
contextPtr->glVertexAttrib4Nuiv = (delegate*<uint, uint*, void>)load(
"glVertexAttrib4Nuiv");
contextPtr->glVertexAttrib4Nusv = (delegate*<uint, ushort*, void>)load(
"glVertexAttrib4Nusv");
contextPtr->glVertexAttrib4bv = (delegate*<uint, sbyte*, void>)load(
"glVertexAttrib4bv");
contextPtr->glVertexAttrib4d = (delegate*<uint, double, double, double, double, void>)load(
"glVertexAttrib4d");
contextPtr->glVertexAttrib4dv = (delegate*<uint, double*, void>)load(
"glVertexAttrib4dv");
contextPtr->glVertexAttrib4f = (delegate*<uint, float, float, float, float, void>)load(
"glVertexAttrib4f");
contextPtr->glVertexAttrib4fv = (delegate*<uint, float*, void>)load(
"glVertexAttrib4fv");
contextPtr->glVertexAttrib4iv = (delegate*<uint, int*, void>)load(
"glVertexAttrib4iv");
contextPtr->glVertexAttrib4s = (delegate*<uint, short, short, short, short, void>)load(
"glVertexAttrib4s");
contextPtr->glVertexAttrib4sv = (delegate*<uint, short*, void>)load(
"glVertexAttrib4sv");
contextPtr->glVertexAttrib4ubv = (delegate*<uint, byte*, void>)load(
"glVertexAttrib4ubv");
contextPtr->glVertexAttrib4uiv = (delegate*<uint, uint*, void>)load(
"glVertexAttrib4uiv");
contextPtr->glVertexAttrib4usv = (delegate*<uint, ushort*, void>)load(
"glVertexAttrib4usv");
contextPtr->glVertexAttribPointer = (delegate*<uint, int, uint, int, uint, void*, void>)load(
"glVertexAttribPointer");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 2.0 APIs");
}
internal static unsafe void LoadGLcore21(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core21)
{
InternalIO.InternalAppendLog("The core version 2.1 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glUniformMatrix2x3fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix2x3fv");
contextPtr->glUniformMatrix2x4fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix2x4fv");
contextPtr->glUniformMatrix3x2fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix3x2fv");
contextPtr->glUniformMatrix3x4fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix3x4fv");
contextPtr->glUniformMatrix4x2fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix4x2fv");
contextPtr->glUniformMatrix4x3fv = (delegate*<int, uint, bool, float*, void>)load(
"glUniformMatrix4x3fv");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 2.1 APIs");
}
internal static unsafe void LoadGLcore30(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core30)
{
InternalIO.InternalAppendLog("The core version 3.0 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBeginConditionalRender = (delegate*<uint, uint, void>)load(
"glBeginConditionalRender");
contextPtr->glBeginTransformFeedback = (delegate*<uint, void>)load(
"glBeginTransformFeedback");
contextPtr->glBindBufferBase = (delegate*<uint, uint, uint, void>)load(
"glBindBufferBase");
contextPtr->glBindBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
"glBindBufferRange");
contextPtr->glBindFragDataLocation = (delegate*<uint, uint, byte*, void>)load(
"glBindFragDataLocation");
contextPtr->glBindFramebuffer = (delegate*<uint, uint, void>)load(
"glBindFramebuffer");
contextPtr->glBindRenderbuffer = (delegate*<uint, uint, void>)load(
"glBindRenderbuffer");
contextPtr->glBindVertexArray = (delegate*<uint, void>)load("glBindVertexArray");
contextPtr->glBlitFramebuffer = (delegate*<int, int, int, int, int, int, int, int, uint, uint, void>)load(
"glBlitFramebuffer");
contextPtr->glCheckFramebufferStatus = (delegate*<uint, uint>)load(
"glCheckFramebufferStatus");
contextPtr->glClampColor = (delegate*<uint, uint, void>)load("glClampColor");
contextPtr->glClearBufferfi = (delegate*<uint, int, float, int, void>)load(
"glClearBufferfi");
contextPtr->glClearBufferfv = (delegate*<uint, int, float*, void>)load(
"glClearBufferfv");
contextPtr->glClearBufferiv = (delegate*<uint, int, int*, void>)load(
"glClearBufferiv");
contextPtr->glClearBufferuiv = (delegate*<uint, int, uint*, void>)load(
"glClearBufferuiv");
contextPtr->glColorMaski = (delegate*<uint, bool, bool, bool, bool, void>)load(
"glColorMaski");
contextPtr->glDeleteFramebuffers = (delegate*<uint, uint*, void>)load(
"glDeleteFramebuffers");
contextPtr->glDeleteRenderbuffers = (delegate*<uint, uint*, void>)load(
"glDeleteRenderbuffers");
contextPtr->glDeleteVertexArrays = (delegate*<int, uint*, void>)load(
"glDeleteVertexArrays");
contextPtr->glDisablei = (delegate*<uint, uint, void>)load("glDisablei");
contextPtr->glEnablei = (delegate*<uint, uint, void>)load("glEnablei");
contextPtr->glEndConditionalRender = (delegate*<void>)load("glEndConditionalRender");
contextPtr->glEndTransformFeedback = (delegate*<void>)load("glEndTransformFeedback");
contextPtr->glFlushMappedBufferRange = (delegate*<uint, IntPtr, UIntPtr, void>)load(
"glFlushMappedBufferRange");
contextPtr->glFramebufferRenderbuffer = (delegate*<uint, uint, uint, uint, void>)load(
"glFramebufferRenderbuffer");
contextPtr->glFramebufferTexture1D = (delegate*<uint, uint, uint, uint, int, void>)load(
"glFramebufferTexture1D");
contextPtr->glFramebufferTexture2D = (delegate*<uint, uint, uint, uint, int, void>)load(
"glFramebufferTexture2D");
contextPtr->glFramebufferTexture3D = (delegate*<uint, uint, uint, uint, int, int, void>)load(
"glFramebufferTexture3D");
contextPtr->glFramebufferTextureLayer = (delegate*<uint, uint, uint, int, int, void>)load(
"glFramebufferTextureLayer");
contextPtr->glGenFramebuffers = (delegate*<uint, uint*, void>)load(
"glGenFramebuffers");
contextPtr->glGenRenderbuffers = (delegate*<int, uint*, void>)load(
"glGenRenderbuffers");
contextPtr->glGenVertexArrays = (delegate*<int, uint*, void>)load(
"glGenVertexArrays");
contextPtr->glGenerateMipmap = (delegate*<uint, void>)load("glGenerateMipmap");
contextPtr->glGetBooleani_v = (delegate*<uint, uint, bool*, void>)load(
"glGetBooleani_v");
contextPtr->glGetFragDataLocation = (delegate*<uint, byte*, int>)load(
"glGetFragDataLocation");
contextPtr->glGetFramebufferAttachmentParameteriv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetFramebufferAttachmentParameteriv");
contextPtr->glGetIntegeri_v = (delegate*<uint, uint, int*, void>)load(
"glGetIntegeri_v");
contextPtr->glGetRenderbufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetRenderbufferParameteriv");
contextPtr->glGetStringi = (delegate*<uint, uint, byte*>)load("glGetStringi");
contextPtr->glGetTexParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glGetTexParameterIiv");
contextPtr->glGetTexParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glGetTexParameterIuiv");
contextPtr->glGetTransformFeedbackVarying = (delegate*<uint, uint, uint, uint*, uint*, uint*, byte*, void>)load(
"glGetTransformFeedbackVarying");
contextPtr->glGetUniformuiv = (delegate*<uint, int, uint*, void>)load(
"glGetUniformuiv");
contextPtr->glGetVertexAttribIiv = (delegate*<uint, uint, int*, void>)load(
"glGetVertexAttribIiv");
contextPtr->glGetVertexAttribIuiv = (delegate*<uint, uint, uint*, void>)load(
"glGetVertexAttribIuiv");
contextPtr->glIsEnabledi = (delegate*<uint, uint, bool>)load("glIsEnabledi");
contextPtr->glIsFramebuffer = (delegate*<uint, bool>)load("glIsFramebuffer");
contextPtr->glIsRenderbuffer = (delegate*<uint, bool>)load("glIsRenderbuffer");
contextPtr->glIsVertexArray = (delegate*<uint, bool>)load("glIsVertexArray");
contextPtr->glMapBufferRange = (delegate*<uint, IntPtr, UIntPtr, uint, void*>)load(
"glMapBufferRange");
contextPtr->glRenderbufferStorage = (delegate*<uint, uint, int, int, void>)load(
"glRenderbufferStorage");
contextPtr->glRenderbufferStorageMultisample = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glRenderbufferStorageMultisample");
contextPtr->glTexParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glTexParameterIiv");
contextPtr->glTexParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glTexParameterIuiv");
contextPtr->glTransformFeedbackVaryings = (delegate*<uint, uint, byte*, byte*, uint, void>)load(
"glTransformFeedbackVaryings");
contextPtr->glUniform1ui = (delegate*<int, uint, void>)load("glUniform1ui");
contextPtr->glUniform1uiv = (delegate*<int, uint, uint*, void>)load("glUniform1uiv");
contextPtr->glUniform2ui = (delegate*<int, uint, uint, void>)load("glUniform2ui");
contextPtr->glUniform2uiv = (delegate*<int, uint, uint*, void>)load("glUniform2uiv");
contextPtr->glUniform3ui = (delegate*<int, uint, uint, uint, void>)load(
"glUniform3ui");
contextPtr->glUniform3uiv = (delegate*<int, uint, uint*, void>)load("glUniform3uiv");
contextPtr->glUniform4ui = (delegate*<int, uint, uint, uint, uint, void>)load(
"glUniform4ui");
contextPtr->glUniform4uiv = (delegate*<int, uint, uint*, void>)load("glUniform4uiv");
contextPtr->glVertexAttribI1i = (delegate*<uint, int, void>)load(
"glVertexAttribI1i");
contextPtr->glVertexAttribI1iv = (delegate*<uint, int*, void>)load(
"glVertexAttribI1iv");
contextPtr->glVertexAttribI1ui = (delegate*<uint, uint, void>)load(
"glVertexAttribI1ui");
contextPtr->glVertexAttribI1uiv = (delegate*<uint, uint*, void>)load(
"glVertexAttribI1uiv");
contextPtr->glVertexAttribI2i = (delegate*<uint, int, int, void>)load(
"glVertexAttribI2i");
contextPtr->glVertexAttribI2iv = (delegate*<uint, int*, void>)load(
"glVertexAttribI2iv");
contextPtr->glVertexAttribI2ui = (delegate*<uint, uint, uint, void>)load(
"glVertexAttribI2ui");
contextPtr->glVertexAttribI2uiv = (delegate*<uint, uint*, void>)load(
"glVertexAttribI2uiv");
contextPtr->glVertexAttribI3i = (delegate*<uint, int, int, int, void>)load(
"glVertexAttribI3i");
contextPtr->glVertexAttribI3iv = (delegate*<uint, int*, void>)load(
"glVertexAttribI3iv");
contextPtr->glVertexAttribI3ui = (delegate*<uint, uint, uint, uint, void>)load(
"glVertexAttribI3ui");
contextPtr->glVertexAttribI3uiv = (delegate*<uint, uint*, void>)load(
"glVertexAttribI3uiv");
contextPtr->glVertexAttribI4bv = (delegate*<uint, sbyte*, void>)load(
"glVertexAttribI4bv");
contextPtr->glVertexAttribI4i = (delegate*<uint, int, int, int, int, void>)load(
"glVertexAttribI4i");
contextPtr->glVertexAttribI4iv = (delegate*<uint, int*, void>)load(
"glVertexAttribI4iv");
contextPtr->glVertexAttribI4sv = (delegate*<uint, short*, void>)load(
"glVertexAttribI4sv");
contextPtr->glVertexAttribI4ubv = (delegate*<uint, byte*, void>)load(
"glVertexAttribI4ubv");
contextPtr->glVertexAttribI4ui = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glVertexAttribI4ui");
contextPtr->glVertexAttribI4uiv = (delegate*<uint, uint*, void>)load(
"glVertexAttribI4uiv");
contextPtr->glVertexAttribI4usv = (delegate*<uint, ushort*, void>)load(
"glVertexAttribI4usv");
contextPtr->glVertexAttribIPointer = (delegate*<uint, int, uint, uint, void*, void>)load(
"glVertexAttribIPointer");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 3.0 APIs");
}
internal static unsafe void LoadGLcore31(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core31)
{
InternalIO.InternalAppendLog("The core version 3.1 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindBufferBase = (delegate*<uint, uint, uint, void>)load(
"glBindBufferBase");
contextPtr->glBindBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
"glBindBufferRange");
contextPtr->glCopyBufferSubData = (delegate*<uint, uint, IntPtr, IntPtr, UIntPtr, void>)load(
"glCopyBufferSubData");
contextPtr->glDrawArraysInstanced = (delegate*<uint, int, uint, uint, void>)load(
"glDrawArraysInstanced");
contextPtr->glDrawElementsInstanced = (delegate*<uint, uint, uint, void*, uint, void>)load(
"glDrawElementsInstanced");
contextPtr->glGetActiveUniformBlockName = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
"glGetActiveUniformBlockName");
contextPtr->glGetActiveUniformBlockiv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetActiveUniformBlockiv");
contextPtr->glGetActiveUniformName = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
"glGetActiveUniformName");
contextPtr->glGetActiveUniformsiv = (delegate*<uint, uint, uint*, uint, int*, void>)load(
"glGetActiveUniformsiv");
contextPtr->glGetIntegeri_v = (delegate*<uint, uint, int*, void>)load(
"glGetIntegeri_v");
contextPtr->glGetUniformBlockIndex = (delegate*<uint, byte*, uint>)load(
"glGetUniformBlockIndex");
contextPtr->glGetUniformIndices = (delegate*<uint, uint, byte*, char**, uint*, void>)load(
"glGetUniformIndices");
contextPtr->glPrimitiveRestartIndex = (delegate*<uint, void>)load(
"glPrimitiveRestartIndex");
contextPtr->glTexBuffer = (delegate*<uint, uint, uint, void>)load("glTexBuffer");
contextPtr->glUniformBlockBinding = (delegate*<uint, uint, uint, void>)load(
"glUniformBlockBinding");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 3.1 APIs");
}
internal static unsafe void LoadGLcore32(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core32)
{
InternalIO.InternalAppendLog("The core version 3.2 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glClientWaitSync = (delegate*<GLsync, uint, ulong, uint>)load(
"glClientWaitSync");
contextPtr->glDeleteSync = (delegate*<GLsync, void>)load("glDeleteSync");
contextPtr->glDrawElementsBaseVertex = (delegate*<uint, uint, uint, void*, int, void>)load(
"glDrawElementsBaseVertex");
contextPtr->glDrawElementsInstancedBaseVertex = (delegate*<uint, uint, uint, void*, uint, int, void>)load(
"glDrawElementsInstancedBaseVertex");
contextPtr->glDrawRangeElementsBaseVertex = (delegate*<uint, uint, uint, uint, uint, void*, int, void>)load(
"glDrawRangeElementsBaseVertex");
contextPtr->glFenceSync = (delegate*<uint, uint, GLsync>)load("glFenceSync");
contextPtr->glFramebufferTexture = (delegate*<uint, uint, uint, int, void>)load(
"glFramebufferTexture");
contextPtr->glGetBufferParameteri64v = (delegate*<uint, uint, long*, void>)load(
"glGetBufferParameteri64v");
contextPtr->glGetInteger64i_v = (delegate*<uint, uint, long*, void>)load(
"glGetInteger64i_v");
contextPtr->glGetInteger64v = (delegate*<uint, long*, void>)load("glGetInteger64v");
contextPtr->glGetMultisamplefv = (delegate*<uint, uint, float*, void>)load(
"glGetMultisamplefv");
contextPtr->glGetSynciv = (delegate*<GLsync, uint, uint, uint*, int*, void>)load(
"glGetSynciv");
contextPtr->glIsSync = (delegate*<GLsync, bool>)load("glIsSync");
contextPtr->glMultiDrawElementsBaseVertex = (delegate*<uint, uint*, uint, void*, void**, uint, int*, void>)load(
"glMultiDrawElementsBaseVertex");
contextPtr->glProvokingVertex = (delegate*<uint, void>)load("glProvokingVertex");
contextPtr->glSampleMaski = (delegate*<uint, uint, void>)load("glSampleMaski");
contextPtr->glTexImage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
"glTexImage2DMultisample");
contextPtr->glTexImage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
"glTexImage3DMultisample");
contextPtr->glWaitSync = (delegate*<GLsync, uint, ulong, void>)load("glWaitSync");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 3.2 APIs");
}
internal static unsafe void LoadGLcore33(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core33)
{
InternalIO.InternalAppendLog("The core version 3.3 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindFragDataLocationIndexed = (delegate*<uint, uint, uint, byte*, void>)load(
"glBindFragDataLocationIndexed");
contextPtr->glBindSampler = (delegate*<uint, uint, void>)load("glBindSampler");
contextPtr->glDeleteSamplers = (delegate*<uint, uint*, void>)load(
"glDeleteSamplers");
contextPtr->glGenSamplers = (delegate*<uint, uint*, void>)load("glGenSamplers");
contextPtr->glGetFragDataIndex = (delegate*<uint, byte*, int>)load(
"glGetFragDataIndex");
contextPtr->glGetQueryObjecti64v = (delegate*<uint, uint, long*, void>)load(
"glGetQueryObjecti64v");
contextPtr->glGetQueryObjectui64v = (delegate*<uint, uint, ulong*, void>)load(
"glGetQueryObjectui64v");
contextPtr->glGetSamplerParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glGetSamplerParameterIiv");
contextPtr->glGetSamplerParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glGetSamplerParameterIuiv");
contextPtr->glGetSamplerParameterfv = (delegate*<uint, uint, float*, void>)load(
"glGetSamplerParameterfv");
contextPtr->glGetSamplerParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetSamplerParameteriv");
contextPtr->glIsSampler = (delegate*<uint, bool>)load("glIsSampler");
contextPtr->glQueryCounter = (delegate*<uint, uint, void>)load("glQueryCounter");
contextPtr->glSamplerParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glSamplerParameterIiv");
contextPtr->glSamplerParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glSamplerParameterIuiv");
contextPtr->glSamplerParameterf = (delegate*<uint, uint, float, void>)load(
"glSamplerParameterf");
contextPtr->glSamplerParameterfv = (delegate*<uint, uint, float*, void>)load(
"glSamplerParameterfv");
contextPtr->glSamplerParameteri = (delegate*<uint, uint, int, void>)load(
"glSamplerParameteri");
contextPtr->glSamplerParameteriv = (delegate*<uint, uint, int*, void>)load(
"glSamplerParameteriv");
contextPtr->glVertexAttribDivisor = (delegate*<uint, uint, void>)load(
"glVertexAttribDivisor");
contextPtr->glVertexAttribP1ui = (delegate*<uint, uint, bool, uint, void>)load(
"glVertexAttribP1ui");
contextPtr->glVertexAttribP1uiv = (delegate*<uint, uint, bool, uint*, void>)load(
"glVertexAttribP1uiv");
contextPtr->glVertexAttribP2ui = (delegate*<uint, uint, bool, uint, void>)load(
"glVertexAttribP2ui");
contextPtr->glVertexAttribP2uiv = (delegate*<uint, uint, bool, uint*, void>)load(
"glVertexAttribP2uiv");
contextPtr->glVertexAttribP3ui = (delegate*<uint, uint, bool, uint, void>)load(
"glVertexAttribP3ui");
contextPtr->glVertexAttribP3uiv = (delegate*<uint, uint, bool, uint*, void>)load(
"glVertexAttribP3uiv");
contextPtr->glVertexAttribP4ui = (delegate*<uint, uint, bool, uint, void>)load(
"glVertexAttribP4ui");
contextPtr->glVertexAttribP4uiv = (delegate*<uint, uint, bool, uint*, void>)load(
"glVertexAttribP4uiv");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 3.3 APIs");
}
internal static unsafe void LoadGLcore40(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core40)
{
InternalIO.InternalAppendLog("The core version 4.0 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBeginQueryIndexed = (delegate*<uint, uint, uint, void>)load(
"glBeginQueryIndexed");
contextPtr->glBindTransformFeedback = (delegate*<uint, uint, void>)load(
"glBindTransformFeedback");
contextPtr->glBlendEquationSeparatei = (delegate*<uint, uint, uint, void>)load(
"glBlendEquationSeparatei");
contextPtr->glBlendEquationi = (delegate*<uint, uint, void>)load("glBlendEquationi");
contextPtr->glBlendFuncSeparatei = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glBlendFuncSeparatei");
contextPtr->glBlendFunci = (delegate*<uint, uint, uint, void>)load("glBlendFunci");
contextPtr->glDeleteTransformFeedbacks = (delegate*<uint, uint*, void>)load(
"glDeleteTransformFeedbacks");
contextPtr->glDrawArraysIndirect = (delegate*<uint, void*, void>)load(
"glDrawArraysIndirect");
contextPtr->glDrawElementsIndirect = (delegate*<uint, uint, void*, void>)load(
"glDrawElementsIndirect");
contextPtr->glDrawTransformFeedback = (delegate*<uint, uint, void>)load(
"glDrawTransformFeedback");
contextPtr->glDrawTransformFeedbackStream = (delegate*<uint, uint, uint, void>)load(
"glDrawTransformFeedbackStream");
contextPtr->glEndQueryIndexed = (delegate*<uint, uint, void>)load(
"glEndQueryIndexed");
contextPtr->glGenTransformFeedbacks = (delegate*<uint, uint*, void>)load(
"glGenTransformFeedbacks");
contextPtr->glGetActiveSubroutineName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
"glGetActiveSubroutineName");
contextPtr->glGetActiveSubroutineUniformName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
"glGetActiveSubroutineUniformName");
contextPtr->glGetActiveSubroutineUniformiv = (delegate*<uint, uint, uint, uint, int*, void>)load(
"glGetActiveSubroutineUniformiv");
contextPtr->glGetProgramStageiv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetProgramStageiv");
contextPtr->glGetQueryIndexediv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetQueryIndexediv");
contextPtr->glGetSubroutineIndex = (delegate*<uint, uint, byte*, uint>)load(
"glGetSubroutineIndex");
contextPtr->glGetSubroutineUniformLocation = (delegate*<uint, uint, byte*, int>)load(
"glGetSubroutineUniformLocation");
contextPtr->glGetUniformSubroutineuiv = (delegate*<uint, int, uint*, void>)load(
"glGetUniformSubroutineuiv");
contextPtr->glGetUniformdv = (delegate*<uint, int, double*, void>)load(
"glGetUniformdv");
contextPtr->glIsTransformFeedback = (delegate*<uint, bool>)load(
"glIsTransformFeedback");
contextPtr->glMinSampleShading = (delegate*<float, void>)load("glMinSampleShading");
contextPtr->glPatchParameterfv = (delegate*<uint, float*, void>)load(
"glPatchParameterfv");
contextPtr->glPatchParameteri = (delegate*<uint, int, void>)load(
"glPatchParameteri");
contextPtr->glPauseTransformFeedback = (delegate*<void>)load(
"glPauseTransformFeedback");
contextPtr->glResumeTransformFeedback = (delegate*<void>)load(
"glResumeTransformFeedback");
contextPtr->glUniform1d = (delegate*<int, double, void>)load("glUniform1d");
contextPtr->glUniform1dv = (delegate*<int, uint, double*, void>)load("glUniform1dv");
contextPtr->glUniform2d = (delegate*<int, double, double, void>)load("glUniform2d");
contextPtr->glUniform2dv = (delegate*<int, uint, double*, void>)load("glUniform2dv");
contextPtr->glUniform3d = (delegate*<int, double, double, double, void>)load(
"glUniform3d");
contextPtr->glUniform3dv = (delegate*<int, uint, double*, void>)load("glUniform3dv");
contextPtr->glUniform4d = (delegate*<int, double, double, double, double, void>)load(
"glUniform4d");
contextPtr->glUniform4dv = (delegate*<int, uint, double*, void>)load("glUniform4dv");
contextPtr->glUniformMatrix2dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix2dv");
contextPtr->glUniformMatrix2x3dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix2x3dv");
contextPtr->glUniformMatrix2x4dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix2x4dv");
contextPtr->glUniformMatrix3dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix3dv");
contextPtr->glUniformMatrix3x2dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix3x2dv");
contextPtr->glUniformMatrix3x4dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix3x4dv");
contextPtr->glUniformMatrix4dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix4dv");
contextPtr->glUniformMatrix4x2dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix4x2dv");
contextPtr->glUniformMatrix4x3dv = (delegate*<int, uint, bool, double*, void>)load(
"glUniformMatrix4x3dv");
contextPtr->glUniformSubroutinesuiv = (delegate*<uint, uint, uint*, void>)load(
"glUniformSubroutinesuiv");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.0 APIs");
}
internal static unsafe void LoadGLcore41(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core41)
{
InternalIO.InternalAppendLog("The core version 4.1 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glActiveShaderProgram = (delegate*<uint, uint, void>)load(
"glActiveShaderProgram");
contextPtr->glBindProgramPipeline = (delegate*<uint, void>)load(
"glBindProgramPipeline");
contextPtr->glClearDepthf = (delegate*<float, void>)load("glClearDepthf");
contextPtr->glCreateShaderProgramv = (delegate*<uint, uint, byte*, uint>)load(
"glCreateShaderProgramv");
contextPtr->glDeleteProgramPipelines = (delegate*<uint, uint*, void>)load(
"glDeleteProgramPipelines");
contextPtr->glDepthRangeArrayv = (delegate*<uint, uint, double*, void>)load(
"glDepthRangeArrayv");
contextPtr->glDepthRangeIndexed = (delegate*<uint, double, double, void>)load(
"glDepthRangeIndexed");
contextPtr->glDepthRangef = (delegate*<float, float, void>)load("glDepthRangef");
contextPtr->glGenProgramPipelines = (delegate*<uint, uint*, void>)load(
"glGenProgramPipelines");
contextPtr->glGetDoublei_v = (delegate*<uint, uint, double*, void>)load(
"glGetDoublei_v");
contextPtr->glGetFloati_v = (delegate*<uint, uint, float*, void>)load(
"glGetFloati_v");
contextPtr->glGetProgramBinary = (delegate*<uint, uint, uint*, uint*, void*, void>)load(
"glGetProgramBinary");
contextPtr->glGetProgramPipelineInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
"glGetProgramPipelineInfoLog");
contextPtr->glGetProgramPipelineiv = (delegate*<uint, uint, int*, void>)load(
"glGetProgramPipelineiv");
contextPtr->glGetShaderPrecisionFormat = (delegate*<uint, uint, int*, int*, void>)load(
"glGetShaderPrecisionFormat");
contextPtr->glGetVertexAttribLdv = (delegate*<uint, uint, double*, void>)load(
"glGetVertexAttribLdv");
contextPtr->glIsProgramPipeline = (delegate*<uint, bool>)load("glIsProgramPipeline");
contextPtr->glProgramBinary = (delegate*<uint, uint, void*, uint, void>)load(
"glProgramBinary");
contextPtr->glProgramParameteri = (delegate*<uint, uint, int, void>)load(
"glProgramParameteri");
contextPtr->glProgramUniform1d = (delegate*<uint, int, double, void>)load(
"glProgramUniform1d");
contextPtr->glProgramUniform1dv = (delegate*<uint, int, uint, double*, void>)load(
"glProgramUniform1dv");
contextPtr->glProgramUniform1f = (delegate*<uint, int, float, void>)load(
"glProgramUniform1f");
contextPtr->glProgramUniform1fv = (delegate*<uint, int, uint, float*, void>)load(
"glProgramUniform1fv");
contextPtr->glProgramUniform1i = (delegate*<uint, int, int, void>)load(
"glProgramUniform1i");
contextPtr->glProgramUniform1iv = (delegate*<uint, int, uint, int*, void>)load(
"glProgramUniform1iv");
contextPtr->glProgramUniform1ui = (delegate*<uint, int, uint, void>)load(
"glProgramUniform1ui");
contextPtr->glProgramUniform1uiv = (delegate*<uint, int, uint, uint*, void>)load(
"glProgramUniform1uiv");
contextPtr->glProgramUniform2d = (delegate*<uint, int, double, double, void>)load(
"glProgramUniform2d");
contextPtr->glProgramUniform2dv = (delegate*<uint, int, uint, double*, void>)load(
"glProgramUniform2dv");
contextPtr->glProgramUniform2f = (delegate*<uint, int, float, float, void>)load(
"glProgramUniform2f");
contextPtr->glProgramUniform2fv = (delegate*<uint, int, uint, float*, void>)load(
"glProgramUniform2fv");
contextPtr->glProgramUniform2i = (delegate*<uint, int, int, int, void>)load(
"glProgramUniform2i");
contextPtr->glProgramUniform2iv = (delegate*<uint, int, uint, int*, void>)load(
"glProgramUniform2iv");
contextPtr->glProgramUniform2ui = (delegate*<uint, int, uint, uint, void>)load(
"glProgramUniform2ui");
contextPtr->glProgramUniform2uiv = (delegate*<uint, int, uint, uint*, void>)load(
"glProgramUniform2uiv");
contextPtr->glProgramUniform3d = (delegate*<uint, int, double, double, double, void>)load(
"glProgramUniform3d");
contextPtr->glProgramUniform3dv = (delegate*<uint, int, uint, double*, void>)load(
"glProgramUniform3dv");
contextPtr->glProgramUniform3f = (delegate*<uint, int, float, float, float, void>)load(
"glProgramUniform3f");
contextPtr->glProgramUniform3fv = (delegate*<uint, int, uint, float*, void>)load(
"glProgramUniform3fv");
contextPtr->glProgramUniform3i = (delegate*<uint, int, int, int, int, void>)load(
"glProgramUniform3i");
contextPtr->glProgramUniform3iv = (delegate*<uint, int, uint, int*, void>)load(
"glProgramUniform3iv");
contextPtr->glProgramUniform3ui = (delegate*<uint, int, uint, uint, uint, void>)load(
"glProgramUniform3ui");
contextPtr->glProgramUniform3uiv = (delegate*<uint, int, uint, uint*, void>)load(
"glProgramUniform3uiv");
contextPtr->glProgramUniform4d = (delegate*<uint, int, double, double, double, double, void>)load(
"glProgramUniform4d");
contextPtr->glProgramUniform4dv = (delegate*<uint, int, uint, double*, void>)load(
"glProgramUniform4dv");
contextPtr->glProgramUniform4f = (delegate*<uint, int, float, float, float, float, void>)load(
"glProgramUniform4f");
contextPtr->glProgramUniform4fv = (delegate*<uint, int, uint, float*, void>)load(
"glProgramUniform4fv");
contextPtr->glProgramUniform4i = (delegate*<uint, int, int, int, int, int, void>)load(
"glProgramUniform4i");
contextPtr->glProgramUniform4iv = (delegate*<uint, int, uint, int*, void>)load(
"glProgramUniform4iv");
contextPtr->glProgramUniform4ui = (delegate*<uint, int, uint, uint, uint, uint, void>)load(
"glProgramUniform4ui");
contextPtr->glProgramUniform4uiv = (delegate*<uint, int, uint, uint*, void>)load(
"glProgramUniform4uiv");
contextPtr->glProgramUniformMatrix2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix2dv");
contextPtr->glProgramUniformMatrix2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix2fv");
contextPtr->glProgramUniformMatrix2x3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix2x3dv");
contextPtr->glProgramUniformMatrix2x3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix2x3fv");
contextPtr->glProgramUniformMatrix2x4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix2x4dv");
contextPtr->glProgramUniformMatrix2x4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix2x4fv");
contextPtr->glProgramUniformMatrix3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix3dv");
contextPtr->glProgramUniformMatrix3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix3fv");
contextPtr->glProgramUniformMatrix3x2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix3x2dv");
contextPtr->glProgramUniformMatrix3x2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix3x2fv");
contextPtr->glProgramUniformMatrix3x4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix3x4dv");
contextPtr->glProgramUniformMatrix3x4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix3x4fv");
contextPtr->glProgramUniformMatrix4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix4dv");
contextPtr->glProgramUniformMatrix4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix4fv");
contextPtr->glProgramUniformMatrix4x2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix4x2dv");
contextPtr->glProgramUniformMatrix4x2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix4x2fv");
contextPtr->glProgramUniformMatrix4x3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
"glProgramUniformMatrix4x3dv");
contextPtr->glProgramUniformMatrix4x3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
"glProgramUniformMatrix4x3fv");
contextPtr->glReleaseShaderCompiler = (delegate*<void>)load(
"glReleaseShaderCompiler");
contextPtr->glScissorArrayv = (delegate*<uint, uint, int*, void>)load(
"glScissorArrayv");
contextPtr->glScissorIndexed = (delegate*<uint, int, int, uint, uint, void>)load(
"glScissorIndexed");
contextPtr->glScissorIndexedv = (delegate*<uint, int*, void>)load(
"glScissorIndexedv");
contextPtr->glShaderBinary = (delegate*<uint, uint*, uint, void*, uint, void>)load(
"glShaderBinary");
contextPtr->glUseProgramStages = (delegate*<uint, uint, uint, void>)load(
"glUseProgramStages");
contextPtr->glValidateProgramPipeline = (delegate*<uint, void>)load(
"glValidateProgramPipeline");
contextPtr->glVertexAttribL1d = (delegate*<uint, double, void>)load(
"glVertexAttribL1d");
contextPtr->glVertexAttribL1dv = (delegate*<uint, double*, void>)load(
"glVertexAttribL1dv");
contextPtr->glVertexAttribL2d = (delegate*<uint, double, double, void>)load(
"glVertexAttribL2d");
contextPtr->glVertexAttribL2dv = (delegate*<uint, double*, void>)load(
"glVertexAttribL2dv");
contextPtr->glVertexAttribL3d = (delegate*<uint, double, double, double, void>)load(
"glVertexAttribL3d");
contextPtr->glVertexAttribL3dv = (delegate*<uint, double*, void>)load(
"glVertexAttribL3dv");
contextPtr->glVertexAttribL4d = (delegate*<uint, double, double, double, double, void>)load(
"glVertexAttribL4d");
contextPtr->glVertexAttribL4dv = (delegate*<uint, double*, void>)load(
"glVertexAttribL4dv");
contextPtr->glVertexAttribLPointer = (delegate*<uint, int, uint, uint, void*, void>)load(
"glVertexAttribLPointer");
contextPtr->glViewportArrayv = (delegate*<uint, uint, float*, void>)load(
"glViewportArrayv");
contextPtr->glViewportIndexedf = (delegate*<uint, float, float, float, float, void>)load(
"glViewportIndexedf");
contextPtr->glViewportIndexedfv = (delegate*<uint, float*, void>)load(
"glViewportIndexedfv");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.1 APIs");
}
internal static unsafe void LoadGLcore42(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core42)
{
InternalIO.InternalAppendLog("The core version 4.2 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindImageTexture = (delegate*<uint, uint, int, bool, int, uint, uint, void>)load(
"glBindImageTexture");
contextPtr->glDrawArraysInstancedBaseInstance = (delegate*<uint, int, uint, uint, uint, void>)load(
"glDrawArraysInstancedBaseInstance");
contextPtr->glDrawElementsInstancedBaseInstance = (delegate*<uint, uint, uint, void*, uint, uint, void>)load(
"glDrawElementsInstancedBaseInstance");
contextPtr->glDrawElementsInstancedBaseVertexBaseInstance = (delegate*<uint, uint, uint, void*, uint, int, uint, void>)load(
"glDrawElementsInstancedBaseVertexBaseInstance");
contextPtr->glDrawTransformFeedbackInstanced = (delegate*<uint, uint, uint, void>)load(
"glDrawTransformFeedbackInstanced");
contextPtr->glDrawTransformFeedbackStreamInstanced = (delegate*<uint, uint, uint, uint, void>)load(
"glDrawTransformFeedbackStreamInstanced");
contextPtr->glGetActiveAtomicCounterBufferiv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetActiveAtomicCounterBufferiv");
contextPtr->glGetInternalformativ = (delegate*<uint, uint, uint, uint, int*, void>)load(
"glGetInternalformativ");
contextPtr->glMemoryBarrier = (delegate*<uint, void>)load("glMemoryBarrier");
contextPtr->glTexStorage1D = (delegate*<uint, uint, uint, uint, void>)load(
"glTexStorage1D");
contextPtr->glTexStorage2D = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glTexStorage2D");
contextPtr->glTexStorage3D = (delegate*<uint, uint, uint, uint, uint, uint, void>)load(
"glTexStorage3D");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.2 APIs");
}
internal static unsafe void LoadGLcore43(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core43)
{
InternalIO.InternalAppendLog("The core version 4.3 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindVertexBuffer = (delegate*<uint, uint, IntPtr, uint, void>)load(
"glBindVertexBuffer");
contextPtr->glClearBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
"glClearBufferData");
contextPtr->glClearBufferSubData = (delegate*<uint, uint, IntPtr, UIntPtr, uint, uint, void*, void>)load(
"glClearBufferSubData");
contextPtr->glCopyImageSubData = (delegate*<uint, uint, int, int, int, int, uint, uint, int, int, int, int, uint, uint, uint, void>)load(
"glCopyImageSubData");
contextPtr->glDebugMessageCallback = (delegate*<GLDEBUGPROC, void*, void>)load(
"glDebugMessageCallback");
contextPtr->glDebugMessageControl = (delegate*<uint, uint, uint, uint, uint*, bool, void>)load(
"glDebugMessageControl");
contextPtr->glDebugMessageInsert = (delegate*<uint, uint, uint, uint, uint, byte*, void>)load(
"glDebugMessageInsert");
contextPtr->glDispatchCompute = (delegate*<uint, uint, uint, void>)load(
"glDispatchCompute");
contextPtr->glDispatchComputeIndirect = (delegate*<IntPtr, void>)load(
"glDispatchComputeIndirect");
contextPtr->glFramebufferParameteri = (delegate*<uint, uint, int, void>)load(
"glFramebufferParameteri");
contextPtr->glGetDebugMessageLog = (delegate*<uint, uint, uint*, uint*, uint*, uint*, uint*, byte*, uint>)load(
"glGetDebugMessageLog");
contextPtr->glGetFramebufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetFramebufferParameteriv");
contextPtr->glGetInternalformati64v = (delegate*<uint, uint, uint, uint, long*, void>)load(
"glGetInternalformati64v");
contextPtr->glGetObjectLabel = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
"glGetObjectLabel");
contextPtr->glGetObjectPtrLabel = (delegate*<void*, uint, uint*, byte*, void>)load(
"glGetObjectPtrLabel");
contextPtr->glGetPointerv = (delegate*<uint, void**, void>)load("glGetPointerv");
contextPtr->glGetProgramInterfaceiv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetProgramInterfaceiv");
contextPtr->glGetProgramResourceIndex = (delegate*<uint, uint, byte*, uint>)load(
"glGetProgramResourceIndex");
contextPtr->glGetProgramResourceLocation = (delegate*<uint, uint, byte*, int>)load(
"glGetProgramResourceLocation");
contextPtr->glGetProgramResourceLocationIndex = (delegate*<uint, uint, byte*, int>)load(
"glGetProgramResourceLocationIndex");
contextPtr->glGetProgramResourceName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
"glGetProgramResourceName");
contextPtr->glGetProgramResourceiv = (delegate*<uint, uint, uint, uint, uint*, uint, uint*, int*, void>)load(
"glGetProgramResourceiv");
contextPtr->glInvalidateBufferData = (delegate*<uint, void>)load(
"glInvalidateBufferData");
contextPtr->glInvalidateBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void>)load(
"glInvalidateBufferSubData");
contextPtr->glInvalidateFramebuffer = (delegate*<uint, uint, uint*, void>)load(
"glInvalidateFramebuffer");
contextPtr->glInvalidateSubFramebuffer = (delegate*<uint, uint, uint*, int, int, uint, uint, void>)load(
"glInvalidateSubFramebuffer");
contextPtr->glInvalidateTexImage = (delegate*<uint, int, void>)load(
"glInvalidateTexImage");
contextPtr->glInvalidateTexSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, void>)load(
"glInvalidateTexSubImage");
contextPtr->glMultiDrawArraysIndirect = (delegate*<uint, void*, uint, uint, void>)load(
"glMultiDrawArraysIndirect");
contextPtr->glMultiDrawElementsIndirect = (delegate*<uint, uint, void*, uint, uint, void>)load(
"glMultiDrawElementsIndirect");
contextPtr->glObjectLabel = (delegate*<uint, uint, uint, byte*, void>)load(
"glObjectLabel");
contextPtr->glObjectPtrLabel = (delegate*<void*, uint, byte*, void>)load(
"glObjectPtrLabel");
contextPtr->glPopDebugGroup = (delegate*<void>)load("glPopDebugGroup");
contextPtr->glPushDebugGroup = (delegate*<uint, uint, uint, byte*, void>)load(
"glPushDebugGroup");
contextPtr->glShaderStorageBlockBinding = (delegate*<uint, uint, uint, void>)load(
"glShaderStorageBlockBinding");
contextPtr->glTexBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
"glTexBufferRange");
contextPtr->glTexStorage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
"glTexStorage2DMultisample");
contextPtr->glTexStorage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
"glTexStorage3DMultisample");
contextPtr->glTextureView = (delegate*<uint, uint, uint, uint, uint, uint, uint, uint, void>)load(
"glTextureView");
contextPtr->glVertexAttribBinding = (delegate*<uint, uint, void>)load(
"glVertexAttribBinding");
contextPtr->glVertexAttribFormat = (delegate*<uint, int, uint, bool, uint, void>)load(
"glVertexAttribFormat");
contextPtr->glVertexAttribIFormat = (delegate*<uint, int, uint, uint, void>)load(
"glVertexAttribIFormat");
contextPtr->glClearBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
"glClearBufferData");
contextPtr->glVertexBindingDivisor = (delegate*<uint, uint, void>)load(
"glVertexBindingDivisor");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.3 APIs");
}
internal static unsafe void LoadGLcore44(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core44)
{
InternalIO.InternalAppendLog("The core version 4.4 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindBuffersBase = (delegate*<uint, uint, uint, uint*, void>)load(
"glBindBuffersBase");
contextPtr->glBindBuffersRange = (delegate*<uint, uint, uint, uint*, IntPtr*, UIntPtr*, void>)load(
"glBindBuffersRange");
contextPtr->glBindImageTextures = (delegate*<uint, uint, uint*, void>)load(
"glBindImageTextures");
contextPtr->glBindSamplers = (delegate*<uint, uint, uint*, void>)load(
"glBindSamplers");
contextPtr->glBindTextures = (delegate*<uint, uint, uint*, void>)load(
"glBindTextures");
contextPtr->glBindVertexBuffers = (delegate*<uint, uint, uint*, IntPtr*, uint*, void>)load(
"glBindVertexBuffers");
contextPtr->glBufferStorage = (delegate*<uint, UIntPtr, void*, uint, void>)load(
"glBufferStorage");
contextPtr->glClearTexImage = (delegate*<uint, int, uint, uint, void*, void>)load(
"glClearTexImage");
contextPtr->glClearTexSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
"glClearTexSubImage");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.4 APIs");
}
internal static unsafe void LoadGLcore45(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core45)
{
InternalIO.InternalAppendLog("The core version 4.5 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glBindTextureUnit = (delegate*<uint, uint, void>)load(
"glBindTextureUnit");
contextPtr->glBlitNamedFramebuffer = (delegate*<uint, uint, int, int, int, int, int, int, int, int, uint, uint, void>)load(
"glBlitNamedFramebuffer");
contextPtr->glCheckNamedFramebufferStatus = (delegate*<uint, uint, uint>)load(
"glCheckNamedFramebufferStatus");
contextPtr->glClearNamedBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
"glClearNamedBufferData");
contextPtr->glClearNamedBufferSubData = (delegate*<uint, uint, IntPtr, UIntPtr, uint, uint, void*, void>)load(
"glClearNamedBufferSubData");
contextPtr->glClearNamedFramebufferfi = (delegate*<uint, uint, int, float, int, void>)load(
"glClearNamedFramebufferfi");
contextPtr->glClearNamedFramebufferfv = (delegate*<uint, uint, int, float*, void>)load(
"glClearNamedFramebufferfv");
contextPtr->glClearNamedFramebufferiv = (delegate*<uint, uint, int, int*, void>)load(
"glClearNamedFramebufferiv");
contextPtr->glClearNamedFramebufferuiv = (delegate*<uint, uint, int, uint*, void>)load(
"glClearNamedFramebufferuiv");
contextPtr->glClipControl = (delegate*<uint, uint, void>)load("glClipControl");
contextPtr->glCompressedTextureSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
"glCompressedTextureSubImage1D");
contextPtr->glCompressedTextureSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
"glCompressedTextureSubImage2D");
contextPtr->glCompressedTextureSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
"glCompressedTextureSubImage3D");
contextPtr->glCopyNamedBufferSubData = (delegate*<uint, uint, IntPtr, IntPtr, UIntPtr, void>)load(
"glCopyNamedBufferSubData");
contextPtr->glCopyTextureSubImage1D = (delegate*<uint, int, int, int, int, uint, void>)load(
"glCopyTextureSubImage1D");
contextPtr->glCopyTextureSubImage2D = (delegate*<uint, int, int, int, int, int, uint, uint, void>)load(
"glCopyTextureSubImage2D");
contextPtr->glCopyTextureSubImage3D = (delegate*<uint, int, int, int, int, int, int, uint, uint, void>)load(
"glCopyTextureSubImage3D");
contextPtr->glCreateBuffers = (delegate*<uint, uint*, void>)load("glCreateBuffers");
contextPtr->glCreateFramebuffers = (delegate*<uint, uint*, void>)load(
"glCreateFramebuffers");
contextPtr->glCreateProgramPipelines = (delegate*<uint, uint*, void>)load(
"glCreateProgramPipelines");
contextPtr->glCreateQueries = (delegate*<uint, uint, uint*, void>)load(
"glCreateQueries");
contextPtr->glCreateRenderbuffers = (delegate*<uint, uint*, void>)load(
"glCreateRenderbuffers");
contextPtr->glCreateSamplers = (delegate*<uint, uint*, void>)load(
"glCreateSamplers");
contextPtr->glCreateTextures = (delegate*<uint, uint, uint*, void>)load(
"glCreateTextures");
contextPtr->glCreateTransformFeedbacks = (delegate*<uint, uint*, void>)load(
"glCreateTransformFeedbacks");
contextPtr->glCreateVertexArrays = (delegate*<uint, uint*, void>)load(
"glCreateVertexArrays");
contextPtr->glDisableVertexArrayAttrib = (delegate*<uint, uint, void>)load(
"glDisableVertexArrayAttrib");
contextPtr->glEnableVertexArrayAttrib = (delegate*<uint, uint, void>)load(
"glEnableVertexArrayAttrib");
contextPtr->glFlushMappedNamedBufferRange = (delegate*<uint, IntPtr, UIntPtr, void>)load(
"glFlushMappedNamedBufferRange");
contextPtr->glGenerateTextureMipmap = (delegate*<uint, void>)load(
"glGenerateTextureMipmap");
contextPtr->glGetCompressedTextureImage = (delegate*<uint, int, uint, void*, void>)load(
"glGetCompressedTextureImage");
contextPtr->glGetCompressedTextureSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, void*, void>)load(
"glGetCompressedTextureSubImage");
contextPtr->glGetGraphicsResetStatus = (delegate*<uint>)load(
"glGetGraphicsResetStatus");
contextPtr->glGetNamedBufferParameteri64v = (delegate*<uint, uint, long*, void>)load(
"glGetNamedBufferParameteri64v");
contextPtr->glGetNamedBufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetNamedBufferParameteriv");
contextPtr->glGetNamedBufferPointerv = (delegate*<uint, uint, void**, void>)load(
"glGetNamedBufferPointerv");
contextPtr->glGetNamedBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
"glGetNamedBufferSubData");
contextPtr->glGetNamedFramebufferAttachmentParameteriv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetNamedFramebufferAttachmentParameteriv");
contextPtr->glGetNamedFramebufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetNamedFramebufferParameteriv");
contextPtr->glGetNamedRenderbufferParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetNamedRenderbufferParameteriv");
contextPtr->glGetQueryBufferObjecti64v = (delegate*<uint, uint, uint, IntPtr, void>)load(
"glGetQueryBufferObjecti64v");
contextPtr->glGetQueryBufferObjectiv = (delegate*<uint, uint, uint, IntPtr, void>)load(
"glGetQueryBufferObjectiv");
contextPtr->glGetQueryBufferObjectui64v = (delegate*<uint, uint, uint, IntPtr, void>)load(
"glGetQueryBufferObjectui64v");
contextPtr->glGetQueryBufferObjectuiv = (delegate*<uint, uint, uint, IntPtr, void>)load(
"glGetQueryBufferObjectuiv");
contextPtr->glGetTextureImage = (delegate*<uint, int, uint, uint, uint, void*, void>)load(
"glGetTextureImage");
contextPtr->glGetTextureLevelParameterfv = (delegate*<uint, int, uint, float*, void>)load(
"glGetTextureLevelParameterfv");
contextPtr->glGetTextureLevelParameteriv = (delegate*<uint, int, uint, int*, void>)load(
"glGetTextureLevelParameteriv");
contextPtr->glGetTextureParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glGetTextureParameterIiv");
contextPtr->glGetTextureParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glGetTextureParameterIuiv");
contextPtr->glGetTextureParameterfv = (delegate*<uint, uint, float*, void>)load(
"glGetTextureParameterfv");
contextPtr->glGetTextureParameteriv = (delegate*<uint, uint, int*, void>)load(
"glGetTextureParameteriv");
contextPtr->glGetTextureSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, uint, void*, void>)load(
"glGetTextureSubImage");
contextPtr->glGetTransformFeedbacki64_v = (delegate*<uint, uint, uint, long*, void>)load(
"glGetTransformFeedbacki64_v");
contextPtr->glGetTransformFeedbacki_v = (delegate*<uint, uint, uint, int*, void>)load(
"glGetTransformFeedbacki_v");
contextPtr->glGetTransformFeedbackiv = (delegate*<uint, uint, int*, void>)load(
"glGetTransformFeedbackiv");
contextPtr->glGetVertexArrayIndexed64iv = (delegate*<uint, uint, uint, long*, void>)load(
"glGetVertexArrayIndexed64iv");
contextPtr->glGetVertexArrayIndexediv = (delegate*<uint, uint, uint, int*, void>)load(
"glGetVertexArrayIndexediv");
contextPtr->glGetVertexArrayiv = (delegate*<uint, uint, int*, void>)load(
"glGetVertexArrayiv");
contextPtr->glGetnCompressedTexImage = (delegate*<uint, int, uint, void*, void>)load(
"glGetnCompressedTexImage");
contextPtr->glGetnTexImage = (delegate*<uint, int, uint, uint, uint, void*, void>)load(
"glGetnTexImage");
contextPtr->glGetnUniformdv = (delegate*<uint, int, uint, double*, void>)load(
"glGetnUniformdv");
contextPtr->glGetnUniformfv = (delegate*<uint, int, uint, float*, void>)load(
"glGetnUniformfv");
contextPtr->glGetnUniformiv = (delegate*<uint, int, uint, int*, void>)load(
"glGetnUniformiv");
contextPtr->glGetnUniformuiv = (delegate*<uint, int, uint, uint*, void>)load(
"glGetnUniformuiv");
contextPtr->glInvalidateNamedFramebufferData = (delegate*<uint, uint, uint*, void>)load(
"glInvalidateNamedFramebufferData");
contextPtr->glInvalidateNamedFramebufferSubData = (delegate*<uint, uint, uint*, int, int, uint, uint, void>)load(
"glInvalidateNamedFramebufferSubData");
contextPtr->glMapNamedBuffer = (delegate*<uint, uint, void*>)load(
"glMapNamedBuffer");
contextPtr->glMapNamedBufferRange = (delegate*<uint, IntPtr, UIntPtr, uint, void*>)load(
"glMapNamedBufferRange");
contextPtr->glMemoryBarrierByRegion = (delegate*<uint, void>)load(
"glMemoryBarrierByRegion");
contextPtr->glNamedBufferData = (delegate*<uint, UIntPtr, void*, uint, void>)load(
"glNamedBufferData");
contextPtr->glNamedBufferStorage = (delegate*<uint, UIntPtr, void*, uint, void>)load(
"glNamedBufferStorage");
contextPtr->glNamedBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
"glNamedBufferSubData");
contextPtr->glNamedFramebufferDrawBuffer = (delegate*<uint, uint, void>)load(
"glNamedFramebufferDrawBuffer");
contextPtr->glNamedFramebufferDrawBuffers = (delegate*<uint, uint, uint*, void>)load(
"glNamedFramebufferDrawBuffers");
contextPtr->glNamedFramebufferParameteri = (delegate*<uint, uint, int, void>)load(
"glNamedFramebufferParameteri");
contextPtr->glNamedFramebufferReadBuffer = (delegate*<uint, uint, void>)load(
"glNamedFramebufferReadBuffer");
contextPtr->glNamedFramebufferRenderbuffer = (delegate*<uint, uint, uint, uint, void>)load(
"glNamedFramebufferRenderbuffer");
contextPtr->glNamedFramebufferTexture = (delegate*<uint, uint, uint, int, void>)load(
"glNamedFramebufferTexture");
contextPtr->glNamedFramebufferTextureLayer = (delegate*<uint, uint, uint, int, int, void>)load(
"glNamedFramebufferTextureLayer");
contextPtr->glNamedRenderbufferStorage = (delegate*<uint, uint, uint, uint, void>)load(
"glNamedRenderbufferStorage");
contextPtr->glNamedRenderbufferStorageMultisample = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glNamedRenderbufferStorageMultisample");
contextPtr->glReadnPixels = (delegate*<int, int, int, int, uint, uint, uint, void*, void>)load(
"glReadnPixels");
contextPtr->glTextureBarrier = (delegate*<void>)load("glTextureBarrier");
contextPtr->glTextureBuffer = (delegate*<uint, uint, uint, void>)load(
"glTextureBuffer");
contextPtr->glTextureBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
"glTextureBufferRange");
contextPtr->glTextureParameterIiv = (delegate*<uint, uint, int*, void>)load(
"glTextureParameterIiv");
contextPtr->glTextureParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
"glTextureParameterIuiv");
contextPtr->glTextureParameterf = (delegate*<uint, uint, float, void>)load(
"glTextureParameterf");
contextPtr->glTextureParameterfv = (delegate*<uint, uint, float*, void>)load(
"glTextureParameterfv");
contextPtr->glTextureParameteri = (delegate*<uint, uint, int, void>)load(
"glTextureParameteri");
contextPtr->glTextureParameteriv = (delegate*<uint, uint, int*, void>)load(
"glTextureParameteriv");
contextPtr->glTextureStorage1D = (delegate*<uint, uint, uint, uint, void>)load(
"glTextureStorage1D");
contextPtr->glTextureStorage2D = (delegate*<uint, uint, uint, uint, uint, void>)load(
"glTextureStorage2D");
contextPtr->glTextureStorage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
"glTextureStorage2DMultisample");
contextPtr->glTextureStorage3D = (delegate*<uint, uint, uint, uint, uint, uint, void>)load(
"glTextureStorage3D");
contextPtr->glTextureStorage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
"glTextureStorage3DMultisample");
contextPtr->glTextureSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
"glTextureSubImage1D");
contextPtr->glTextureSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
"glTextureSubImage2D");
contextPtr->glTextureSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
"glTextureSubImage3D");
contextPtr->glTransformFeedbackBufferBase = (delegate*<uint, uint, uint, void>)load(
"glTransformFeedbackBufferBase");
contextPtr->glTransformFeedbackBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
"glTransformFeedbackBufferRange");
contextPtr->glUnmapNamedBuffer = (delegate*<uint, bool>)load("glUnmapNamedBuffer");
contextPtr->glVertexArrayAttribBinding = (delegate*<uint, uint, uint, void>)load(
"glVertexArrayAttribBinding");
contextPtr->glVertexArrayAttribFormat = (delegate*<uint, uint, int, uint, bool, uint, void>)load(
"glVertexArrayAttribFormat");
contextPtr->glVertexArrayAttribIFormat = (delegate*<uint, uint, int, uint, uint, void>)load(
"glVertexArrayAttribIFormat");
contextPtr->glVertexArrayAttribLFormat = (delegate*<uint, uint, int, uint, uint, void>)load(
"glVertexArrayAttribLFormat");
contextPtr->glVertexArrayBindingDivisor = (delegate*<uint, uint, uint, void>)load(
"glVertexArrayBindingDivisor");
contextPtr->glVertexArrayElementBuffer = (delegate*<uint, uint, void>)load(
"glVertexArrayElementBuffer");
contextPtr->glVertexArrayVertexBuffer = (delegate*<uint, uint, uint, IntPtr, uint, void>)load(
"glVertexArrayVertexBuffer");
contextPtr->glVertexArrayVertexBuffers = (delegate*<uint, uint, uint, uint*, IntPtr*, uint*, void>)load(
"glVertexArrayVertexBuffers");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.5 APIs");
}
internal static unsafe void LoadGLcore46(OpenglContext* contextPtr, delegate*<string, IntPtr> load)
{
if (!core46)
{
InternalIO.InternalAppendLog("The core version 4.6 is not supported.");
throw new Exception("Final Version");
}
#region load
contextPtr->glMultiDrawArraysIndirectCount = (delegate*<uint, void*, IntPtr, uint, uint, void>)load(
"glMultiDrawArraysIndirectCount");
contextPtr->glMultiDrawElementsIndirectCount = (delegate*<uint, uint, void*, IntPtr, uint, uint, void>)load(
"glMultiDrawElementsIndirectCount");
contextPtr->glPolygonOffsetClamp = (delegate*<float, float, float, void>)load(
"glPolygonOffsetClamp");
contextPtr->glSpecializeShader = (delegate*<uint, byte*, uint, uint*, uint*, void>)load(
"glSpecializeShader");
#endregion load
InternalIO.InternalAppendLog("Successfully load all OpenGL 4.6 APIs");
}
}
}
Reference in New Issue View Git Blame Copy Permalink