4976 lines
225 KiB
C#
4976 lines
225 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="glApiManager.cs"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload Space
|
|
// Copyright (c) Nitload Space. 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");
|
|
}
|
|
|
|
}
|
|
} |