4501 lines
226 KiB
C#
4501 lines
226 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.Math;
|
|
using StgSharp.MVVM;
|
|
using StgSharp.MVVM.View;
|
|
|
|
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 _name
|
|
/// </summary>
|
|
/// <param _name="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( 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 _name="contextHandle"> The handle to current OpenGL viewPortDisplay </param>
|
|
public static unsafe void LoadOpenGLApiTo( IntPtr contextHandle )
|
|
{
|
|
OpenglContext* context = ( OpenglContext* )contextHandle;
|
|
delegate*<string, IntPtr> loader = &InternalIO.glfwGetProcAddress;
|
|
if( ( IntPtr )context->glGetString != IntPtr.Zero ) {
|
|
return;
|
|
}
|
|
IntPtr proc = loader( "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();
|
|
Console.WriteLine( code );
|
|
if( code != 0 ) {
|
|
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;
|
|
}
|
|
|
|
List<string> extensions = new List<string>();
|
|
|
|
for( uint i = 0; i < extensionCount; i++ ) {
|
|
byte* strPtr = context->glGetStringi( glConst.EXTENSIONS, i );
|
|
extensions.Add( Marshal.PtrToStringAnsi( ( IntPtr )strPtr ) );
|
|
}
|
|
|
|
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" );
|
|
}
|
|
|
|
}
|
|
} |