From 57d82af079151a4ecf1a7e819f8c2d377c49bfc1 Mon Sep 17 00:00:00 2001 From: Gyusun Date: Wed, 24 Dec 2025 14:01:34 +0000 Subject: [PATCH] glew-cmake release from glew-2.3.0 --- CMakeLists.txt | 194 ++- build/glew.rc | 16 +- build/glewinfo.rc | 16 +- build/visualinfo.rc | 16 +- config/version | 2 +- doc/advanced.html | 17 +- doc/basic.html | 15 +- doc/build.html | 15 +- doc/credits.html | 15 +- doc/eglew.html | 434 +++++++ doc/glew.html | 1361 ++++++++++---------- doc/glxew.html | 114 +- doc/index.html | 98 +- doc/install.html | 15 +- doc/log.html | 231 +++- doc/wglew.html | 15 +- include/GL/eglew.h | 305 ++++- include/GL/glew.h | 659 +++++++++- include/GL/glxew.h | 16 +- include/GL/wglew.h | 4 +- src/glew.c | 2873 +++++++++++++++++++++++++++++-------------- src/glewinfo.c | 704 ++++++++++- src/visualinfo.c | 40 +- 23 files changed, 5227 insertions(+), 1948 deletions(-) create mode 100644 doc/eglew.html diff --git a/CMakeLists.txt b/CMakeLists.txt index 5bfdcb2..1e224e9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,22 @@ -cmake_minimum_required(VERSION 2.8.12) -project("glew") +cmake_minimum_required(VERSION 2.8.12...4.0) + +file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_MAJOR_STRING REGEX "GLEW_MAJOR[ ]*=[ ]*[0-9]+.*") +string(REGEX REPLACE "GLEW_MAJOR[ ]*=[ ]*([0-9]+)" "\\1" MAJOR_VERSION ${_VERSION_MAJOR_STRING}) +file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_MINOR_STRING REGEX "GLEW_MINOR[ ]*=[ ]*[0-9]+.*") +string(REGEX REPLACE "GLEW_MINOR[ ]*=[ ]*([0-9]+)" "\\1" MINOR_VERSION ${_VERSION_MINOR_STRING}) +file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_PATCH_STRING REGEX "GLEW_MICRO[ ]*=[ ]*[0-9]+.*") +string(REGEX REPLACE "GLEW_MICRO[ ]*=[ ]*([0-9]+)" "\\1" PATCH_VERSION ${_VERSION_PATCH_STRING}) +set(GLEW_VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}) + +if(NOT CMAKE_VERSION VERSION_LESS 3.0) + cmake_policy(SET CMP0048 NEW) + project("glew" VERSION ${GLEW_VERSION} LANGUAGES C) +else() + project("glew" C) + set(CPACK_PACKAGE_VERSION_MAJOR ${MAJOR_VERSION}) + set(CPACK_PACKAGE_VERSION_MINOR ${MAJOR_VERSION}) + set(CPACK_PACKAGE_VERSION_PATCH ${MAJOR_VERSION}) +endif() set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src) set(INCLUDE_DIR "$$") @@ -11,20 +28,17 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin) include("GeneratePkgConfig.cmake") +if (POLICY CMP0077) + cmake_policy(SET CMP0077 NEW) +endif() + option(glew-cmake_BUILD_SHARED "Build the shared glew library" ON) option(glew-cmake_BUILD_STATIC "Build the static glew library" ON) option(USE_GLU "Use GLU" OFF) +option(GLEW_OSMESA "Off-screen Mesa mode" OFF) option(PKG_CONFIG_REPRESENTATIVE_TARGET "Generate pc file for specified target as glew. libglew_static|libglew_shared" OFF) option(ONLY_LIBS "Do not build executables" OFF) -file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_MAJOR_STRING REGEX "GLEW_MAJOR[ ]*=[ ]*[0-9]+.*") -string(REGEX REPLACE "GLEW_MAJOR[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${_VERSION_MAJOR_STRING}) -file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_MINOR_STRING REGEX "GLEW_MINOR[ ]*=[ ]*[0-9]+.*") -string(REGEX REPLACE "GLEW_MINOR[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MINOR ${_VERSION_MINOR_STRING}) -file(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/config/version _VERSION_PATCH_STRING REGEX "GLEW_MICRO[ ]*=[ ]*[0-9]+.*") -string(REGEX REPLACE "GLEW_MICRO[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_PATCH ${_VERSION_PATCH_STRING}) -set(GLEW_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}) - set(LIBGLEW_SRCS ${SRC_DIR}/glew.c) set(DEFINITIONS) @@ -37,17 +51,37 @@ if(MSVC) endif() # Use namespaced libraries when supported -if(${CMAKE_VERSION} VERSION_GREATER 3.14) +if(NOT CMAKE_VERSION VERSION_LESS 3.14) set(USE_NAMESPACED_LIB YES) else() set(USE_NAMESPACED_LIB NO) endif() +if(POLICY CMP0028) + cmake_policy(SET CMP0028 NEW) +endif() + +if(POLICY CMP0042) + cmake_policy(SET CMP0042 NEW) +endif() + if(POLICY CMP0072) set(OpenGL_GL_PREFERENCE GLVND) endif() -find_package(OpenGL REQUIRED) +if(NOT (WIN32 OR APPLE)) + message("Try to find OpenGL with GLVND") + find_package(OpenGL REQUIRED + COMPONENTS OpenGL GLX) +endif() + +if(OPENGL_FOUND AND OpenGL_GLX_FOUND AND TARGET OpenGL::OpenGL) + set(USE_GLVND YES) +else() + message("GLVND not supported. Try find OpenGL legacy") + find_package(OpenGL REQUIRED) + set(USE_GLVND NO) +endif() set(pc_requires) @@ -63,41 +97,126 @@ else() if(USE_NAMESPACED_LIB) list(APPEND LIBRARIES OpenGL::GLU) else() - list(APPEND LIBRARIES OPENGL_glu_LIBRARY) + list(APPEND LIBRARIES ${OPENGL_glu_LIBRARY}) endif() endif() list(APPEND pc_requires gl) if(USE_NAMESPACED_LIB) - list(APPEND LIBRARIES OpenGL::GL) + if(USE_GLVND) + list(APPEND LIBRARIES OpenGL::OpenGL) + else() + list(APPEND LIBRARIES OpenGL::GL) + endif() else() - list(APPEND LIBRARIES OPENGL_opengl_LIBRARY) + if(USE_GLVND) + list(APPEND LIBRARIES ${OPENGL_opengl_LIBRARY}) + else() + list(APPEND LIBRARIES ${OPENGL_gl_LIBRARY}) + endif() endif() +# OS Specific dependencies if(APPLE) - find_library(AGL_LIBRARY AGL) + find_library(AGL_LIBRARY AGL REQUIRED) list(APPEND LIBRARIES ${AGL_LIBRARY}) elseif(NOT WIN32) - find_package(X11 REQUIRED) - - list(APPEND pc_requires x11 xext) - if(USE_NAMESPACED_LIB) - list(APPEND LIBRARIES X11::X11 X11::Xext) + if(GLEW_OSMESA) + find_library(OSMESA_LIBRARY OSMesa REQUIRED) + list(APPEND LIBRARIES ${OSMESA_LIBRARY}) + list(APPEND DEFINITIONS -DGLEW_OSMESA) + list(APPEND pc_requires osmesa) else() - list(APPEND LIBRARIES X11_X11_LIB X11_Xext_LIB) + if(USE_GLVND) + if(NOT OpenGL_GLX_FOUND) + message(FATAL_ERROR "GLX is not found. Try with PREFER_GLVND=NO") + endif() + + if(USE_NAMESPACED_LIB) + list(APPEND LIBRARIES OpenGL::GLX) + else() + list(APPEND LIBRARIES ${OPENGL_glx_LIBRARY}) + endif() + endif() + + find_package(X11 REQUIRED) + + list(APPEND pc_requires x11 xext) + if(USE_NAMESPACED_LIB) + list(APPEND LIBRARIES X11::X11 X11::Xext) + else() + list(APPEND LIBRARIES ${X11_X11_LIB} ${X11_Xext_LIB}) + endif() endif() endif() set(GLEW_TARGETS) +if(NOT CMAKE_INSTALL_LIBDIR) + set(INSTALL_LIBDIR lib) +else() + set(INSTALL_LIBDIR ${CMAKE_INSTALL_LIBDIR}) +endif() + +execute_process( + COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_BINARY_DIR}/test_fs_support_case_sensitivity + COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_BINARY_DIR}/test_fs_support_CASE_sensitivity) +file(GLOB TEST_FILE_LIST ${CMAKE_BINARY_DIR}/test_fs_support_*_sensitivity) +list(LENGTH TEST_FILE_LIST TEST_FILE_COUNT) +if(TEST_FILE_COUNT EQUAL 2) + set(SUPPORT_CASE_SENSITIVE_FS YES) +else() + set(SUPPORT_CASE_SENSITIVE_FS NO) +endif() + +function(set_representative_target TARGET) + set_target_properties(${TARGET} PROPERTIES + OUTPUT_NAME "glew" + DEBUG_POSTFIX d) + + # Windows & macOS use case-insensetive FS. do not create symbolic link + if(SUPPORT_CASE_SENSITIVE_FS) + get_target_property(TARGET_TYPE ${TARGET} TYPE) + string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_LOWER) + if(CMAKE_BUILD_TYPE_LOWER STREQUAL "debug" AND NOT ANDROID) + set(GLEW_DEBUG_SUFFIX "d") + else() + set(GLEW_DEBUG_SUFFIX "") + endif() + if(TARGET_TYPE STREQUAL STATIC_LIBRARY) + set(EXT ".a") + get_target_property(OUT_DIR ${TARGET} ARCHIVE_OUTPUT_DIRECTORY) + else() + set(EXT ".so") + get_target_property(OUT_DIR ${TARGET} LIBRARY_OUTPUT_DIRECTORY) + endif() + if(NOT ${CMAKE_VERSION} VERSION_LESS 3.0) + add_custom_command(TARGET ${TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} ARGS -E create_symlink libglew${GLEW_DEBUG_SUFFIX}${EXT} libGLEW${GLEW_DEBUG_SUFFIX}${EXT} + WORKING_DIRECTORY ${OUT_DIR} + BYPRODUCTS ${OUT_DIR}/libGLEW${GLEW_DEBUG_SUFFIX}${EXT} + COMMENT "create libGLEW${GLEW_DEBUG_SUFFIX} symbolic link") + else() + add_custom_command(TARGET ${TARGET} POST_BUILD + COMMAND bash ARGS -c "( test ! -e ${OUT_DIR}/libGLEW${GLEW_DEBUG_SUFFIX}${EXT} && cd ${OUT_DIR} && ${CMAKE_COMMAND} -E create_symlink libglew${GLEW_DEBUG_SUFFIX}${EXT} libGLEW${GLEW_DEBUG_SUFFIX}${EXT} ) || true" + COMMENT "create libGLEW${GLEW_DEBUG_SUFFIX} symbolic link" + VERBATIM) + endif() + + if(NOT ${CMAKE_VERSION} VERSION_LESS 3.14) + install(FILES ${OUT_DIR}/libGLEW${GLEW_DEBUG_SUFFIX}${EXT} TYPE LIB) + else() + install(FILES ${OUT_DIR}/libGLEW${GLEW_DEBUG_SUFFIX}${EXT} DESTINATION ${INSTALL_LIBDIR}) + endif() + endif() +endfunction() + if(glew-cmake_BUILD_STATIC) add_library(libglew_static STATIC ${LIBGLEW_SRCS}) - set_target_properties(libglew_static PROPERTIES - OUTPUT_NAME "glew" - DEBUG_POSTFIX d) + set_representative_target(libglew_static) - target_compile_definitions(libglew_static PUBLIC GLEW_STATIC) + target_compile_definitions(libglew_static PUBLIC GLEW_STATIC) list(APPEND GLEW_TARGETS libglew_static) endif() @@ -109,33 +228,38 @@ if(glew-cmake_BUILD_SHARED) OUTPUT_NAME "glew-shared" DEBUG_POSTFIX d) else() - set_target_properties(libglew_shared PROPERTIES - OUTPUT_NAME "glew" - DEBUG_POSTFIX d) + set_representative_target(libglew_shared) endif() target_compile_definitions(libglew_shared PRIVATE GLEW_BUILD) + if(MINGW) + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.13) + target_link_options(libglew_shared PRIVATE -nostdlib) + else() + target_link_libraries(libglew_shared PRIVATE -nostdlib) + endif() + endif() list(APPEND GLEW_TARGETS libglew_shared) endif() foreach(GLEW_TARGET ${GLEW_TARGETS}) target_compile_definitions(${GLEW_TARGET} PUBLIC ${DEFINITIONS}) target_include_directories(${GLEW_TARGET} PUBLIC ${INCLUDE_DIR}) - target_link_libraries(${GLEW_TARGET} ${LIBRARIES}) + target_link_libraries(${GLEW_TARGET} PUBLIC ${LIBRARIES}) set_target_properties(${GLEW_TARGET} PROPERTIES VERSION ${GLEW_VERSION}) endforeach() if(PKG_CONFIG_REPRESENTATIVE_TARGET) GeneratePkgConfigFile(${PKG_CONFIG_REPRESENTATIVE_TARGET} "The OpenGL Extension Wrangler library" NAME "glew" - LIBRARY_DIR lib + LIBRARY_DIR ${INSTALL_LIBDIR} REQUIRES ${pc_requires}) endif() -install(TARGETS ${GLEW_TARGETS} - EXPORT glew-cmake - ARCHIVE DESTINATION lib) -install(EXPORT glew-cmake DESTINATION lib/cmake/glew FILE glewConfig.cmake) +install(TARGETS ${GLEW_TARGETS} EXPORT glew-cmake + ARCHIVE DESTINATION ${INSTALL_LIBDIR} + LIBRARY DESTINATION ${INSTALL_LIBDIR}) +install(EXPORT glew-cmake DESTINATION ${INSTALL_LIBDIR}/cmake/glew FILE glewConfig.cmake) file(GLOB PUBLIC_HEADERS "include/GL/*.h") install(FILES ${PUBLIC_HEADERS} DESTINATION include/GL/) diff --git a/build/glew.rc b/build/glew.rc index 82d85ee..9761bf3 100644 --- a/build/glew.rc +++ b/build/glew.rc @@ -19,9 +19,9 @@ // // Version // -VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 2, 0, 0 -PRODUCTVERSION 2, 2, 0, 0 +VS_VERSION_INFO VERSIONINFO +FILEVERSION 2, 3, 0, 0 +PRODUCTVERSION 2, 3, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -40,9 +40,9 @@ BEGIN BEGIN BLOCK "040904b0" BEGIN - VALUE "Comments", + VALUE "Comments", "The OpenGL Extension Wrangler Library\r\n" - "Copyright (C) 2008-2019, Nigel Stewart \r\n" + "Copyright (C) 2008-2025, Nigel Stewart \r\n" "Copyright (C) 2002-2008, Milan Ikits \r\n" "Copyright (C) 2002-2008, Marcelo E. Magallon \r\n" "Copyright (C) 2002, Lev Povalahev\r\n" @@ -118,14 +118,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "The OpenGL Extension Wrangler Library\0" - VALUE "FileVersion", "2,2,0,0\0" + VALUE "FileVersion", "2,3,0,0\0" VALUE "InternalName", "GLEW\0" - VALUE "LegalCopyright", "© 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" + VALUE "LegalCopyright", "(C) 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,2,0,0\0" + VALUE "ProductVersion", "2,3,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/glewinfo.rc b/build/glewinfo.rc index cf61c22..c08c164 100644 --- a/build/glewinfo.rc +++ b/build/glewinfo.rc @@ -11,9 +11,9 @@ // // Version // -VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 2, 0, 0 -PRODUCTVERSION 2, 2, 0, 0 +VS_VERSION_INFO VERSIONINFO +FILEVERSION 2, 3, 0, 0 +PRODUCTVERSION 2, 3, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -28,9 +28,9 @@ BEGIN BEGIN BLOCK "040904b0" BEGIN - VALUE "Comments", + VALUE "Comments", "The OpenGL Extension Wrangler Library\r\n" - "Copyright (C) 2008-2019, Nigel Stewart \r\n" + "Copyright (C) 2008-2025, Nigel Stewart \r\n" "Copyright (C) 2002-2008, Milan Ikits \r\n" "Copyright (C) 2002-2008, Marcelo E. Magallon \r\n" "Copyright (C) 2002, Lev Povalahev\r\n" @@ -106,14 +106,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "Utility for verifying extension entry points\0" - VALUE "FileVersion", "2,2,0,0\0" + VALUE "FileVersion", "2,3,0,0\0" VALUE "InternalName", "glewinfo\0" - VALUE "LegalCopyright", "© 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" + VALUE "LegalCopyright", "(C) 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,2,0,0\0" + VALUE "ProductVersion", "2,3,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/visualinfo.rc b/build/visualinfo.rc index d348512..55c25f9 100644 --- a/build/visualinfo.rc +++ b/build/visualinfo.rc @@ -11,9 +11,9 @@ // // Version // -VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 2, 0, 0 -PRODUCTVERSION 2, 2, 0, 0 +VS_VERSION_INFO VERSIONINFO +FILEVERSION 2, 3, 0, 0 +PRODUCTVERSION 2, 3, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -28,9 +28,9 @@ BEGIN BEGIN BLOCK "040904b0" BEGIN - VALUE "Comments", + VALUE "Comments", "The OpenGL Extension Wrangler Library\r\n" - "Copyright (C) 2008-2019, Nigel Stewart \r\n" + "Copyright (C) 2008-2025, Nigel Stewart \r\n" "Copyright (C) 2002-2008, Milan Ikits \r\n" "Copyright (C) 2002-2008, Marcelo E. Magallon \r\n" "Copyright (C) 2002, Lev Povalahev\r\n" @@ -106,14 +106,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "Utility for listing pixelformat capabilities\0" - VALUE "FileVersion", "2,2,0,0\0" + VALUE "FileVersion", "2,3,0,0\0" VALUE "InternalName", "visualinfo\0" - VALUE "LegalCopyright", "© 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" + VALUE "LegalCopyright", "(C) 2002-2019 Nigel Stewart & Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,2,0,0\0" + VALUE "ProductVersion", "2,3,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/config/version b/config/version index 10f22c3..98b5500 100644 --- a/config/version +++ b/config/version @@ -1,5 +1,5 @@ GLEW_MAJOR = 2 -GLEW_MINOR = 2 +GLEW_MINOR = 3 GLEW_MICRO = 0 GLEW_VERSION = $(GLEW_MAJOR).$(GLEW_MINOR).$(GLEW_MICRO) GLEW_NAME = GLEW diff --git a/doc/advanced.html b/doc/advanced.html index e74f2b6..ae70299 100644 --- a/doc/advanced.html +++ b/doc/advanced.html @@ -1,7 +1,7 @@ @@ -186,7 +183,7 @@ terminated with a semicolon.

Custom Code Generation

Starting from GLEW 1.3.0, it is possible to control which extensions -to include in the libarary by specifying a list in +to include in the library by specifying a list in auto/custom.txt. This is useful when you do not need all the extensions and would like to reduce the size of the source files. Type make clean; make custom in the auto directory diff --git a/doc/basic.html b/doc/basic.html index 783ae7d..bb2149d 100644 --- a/doc/basic.html +++ b/doc/basic.html @@ -1,7 +1,7 @@ diff --git a/doc/build.html b/doc/build.html index 8cf30a1..6ea0e6a 100644 --- a/doc/build.html +++ b/doc/build.html @@ -1,7 +1,7 @@ diff --git a/doc/credits.html b/doc/credits.html index d66835c..2c9b052 100644 --- a/doc/credits.html +++ b/doc/credits.html @@ -1,7 +1,7 @@ diff --git a/doc/eglew.html b/doc/eglew.html new file mode 100644 index 0000000..00e7a75 --- /dev/null +++ b/doc/eglew.html @@ -0,0 +1,434 @@ + + + + + +GLEW: The OpenGL Extension Wrangler Library + + + + + + + + +
+ + + + + + + + +
+ + + + + + + +
Latest Release: 2.3.0

GLEW Logo

+ + + + + + + + + + + + + +
Download
Usage
Building
Installation
Source Generation
Change Log

GitHub
Issues
Pull Requests

SourceForge Page
+

+
+ + + + +
Last Update: 06-20-2025
+ OpenGL Logo
+ GitHub Logo
+ SourceForge Logo +
+
+		 + +

The OpenGL Extension Wrangler Library (GLEW)

+ + + + +

Supported EGL Extensions

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
1 EGL_ANDROID_GLES_layers

2 EGL_ANDROID_blob_cache

3 EGL_ANDROID_create_native_client_buffer

4 EGL_ANDROID_framebuffer_target

5 EGL_ANDROID_front_buffer_auto_refresh

6 EGL_ANDROID_get_frame_timestamps

7 EGL_ANDROID_get_native_client_buffer

8 EGL_ANDROID_image_native_buffer

9 EGL_ANDROID_native_fence_sync

10 EGL_ANDROID_presentation_time

11 EGL_ANDROID_recordable

12 EGL_ANDROID_telemetry_hint

13 EGL_ANGLE_d3d_share_handle_client_buffer

14 EGL_ANGLE_device_d3d

15 EGL_ANGLE_query_surface_pointer

16 EGL_ANGLE_surface_d3d_texture_2d_share_handle

17 EGL_ANGLE_sync_control_rate

18 EGL_ANGLE_window_fixed_size

19 EGL_ARM_image_format

20 EGL_ARM_implicit_external_sync

21 EGL_ARM_pixmap_multisample_discard

22 EGL_EXT_bind_to_front

23 EGL_EXT_buffer_age

24 EGL_EXT_client_extensions

25 EGL_EXT_client_sync

26 EGL_EXT_compositor

27 EGL_EXT_config_select_group

28 EGL_EXT_create_context_robustness

29 EGL_EXT_device_base

30 EGL_EXT_device_drm

31 EGL_EXT_device_drm_render_node

32 EGL_EXT_device_enumeration

33 EGL_EXT_device_openwf

34 EGL_EXT_device_persistent_id

35 EGL_EXT_device_query

36 EGL_EXT_device_query_name

37 EGL_EXT_display_alloc

38 EGL_EXT_explicit_device

39 EGL_EXT_gl_colorspace_bt2020_hlg

40 EGL_EXT_gl_colorspace_bt2020_linear

41 EGL_EXT_gl_colorspace_bt2020_pq

42 EGL_EXT_gl_colorspace_display_p3

43 EGL_EXT_gl_colorspace_display_p3_linear

44 EGL_EXT_gl_colorspace_display_p3_passthrough

45 EGL_EXT_gl_colorspace_scrgb

46 EGL_EXT_gl_colorspace_scrgb_linear

47 EGL_EXT_image_dma_buf_import

48 EGL_EXT_image_dma_buf_import_modifiers

49 EGL_EXT_image_gl_colorspace

50 EGL_EXT_image_implicit_sync_control

51 EGL_EXT_multiview_window

52 EGL_EXT_output_base

53 EGL_EXT_output_drm

54 EGL_EXT_output_openwf

55 EGL_EXT_pixel_format_float

56 EGL_EXT_platform_base

57 EGL_EXT_platform_device

58 EGL_EXT_platform_wayland

59 EGL_EXT_platform_x11

60 EGL_EXT_platform_xcb

61 EGL_EXT_present_opaque

62 EGL_EXT_protected_content

63 EGL_EXT_protected_surface

64 EGL_EXT_query_reset_notification_strategy

65 EGL_EXT_stream_consumer_egloutput

66 EGL_EXT_surface_CTA861_3_metadata

67 EGL_EXT_surface_SMPTE2086_metadata

68 EGL_EXT_surface_compression

69 EGL_EXT_swap_buffers_with_damage

70 EGL_EXT_sync_reuse

71 EGL_EXT_yuv_surface

72 EGL_HI_clientpixmap

73 EGL_HI_colorformats

74 EGL_IMG_context_priority

75 EGL_IMG_image_plane_attribs

76 EGL_KHR_cl_event

77 EGL_KHR_cl_event2

78 EGL_KHR_client_get_all_proc_addresses

79 EGL_KHR_config_attribs

80 EGL_KHR_context_flush_control

81 EGL_KHR_create_context

82 EGL_KHR_create_context_no_error

83 EGL_KHR_debug

84 EGL_KHR_display_reference

85 EGL_KHR_fence_sync

86 EGL_KHR_get_all_proc_addresses

87 EGL_KHR_gl_colorspace

88 EGL_KHR_gl_renderbuffer_image

89 EGL_KHR_gl_texture_2D_image

90 EGL_KHR_gl_texture_3D_image

91 EGL_KHR_gl_texture_cubemap_image

92 EGL_KHR_image

93 EGL_KHR_image_base

94 EGL_KHR_image_pixmap

95 EGL_KHR_lock_surface

96 EGL_KHR_lock_surface2

97 EGL_KHR_lock_surface3

98 EGL_KHR_mutable_render_buffer

99 EGL_KHR_no_config_context

100 EGL_KHR_partial_update

101 EGL_KHR_platform_android

102 EGL_KHR_platform_gbm

103 EGL_KHR_platform_wayland

104 EGL_KHR_platform_x11

105 EGL_KHR_reusable_sync

106 EGL_KHR_stream

107 EGL_KHR_stream_attrib

108 EGL_KHR_stream_consumer_gltexture

109 EGL_KHR_stream_cross_process_fd

110 EGL_KHR_stream_fifo

111 EGL_KHR_stream_producer_aldatalocator

112 EGL_KHR_stream_producer_eglsurface

113 EGL_KHR_surfaceless_context

114 EGL_KHR_swap_buffers_with_damage

115 EGL_KHR_vg_parent_image

116 EGL_KHR_wait_sync

117 EGL_MESA_drm_image

118 EGL_MESA_image_dma_buf_export

119 EGL_MESA_platform_gbm

120 EGL_MESA_platform_surfaceless

121 EGL_MESA_query_driver

122 EGL_NOK_swap_region

123 EGL_NOK_swap_region2

124 EGL_NOK_texture_from_pixmap

125 EGL_NV_3dvision_surface

126 EGL_NV_context_priority_realtime

127 EGL_NV_coverage_sample

128 EGL_NV_coverage_sample_resolve

129 EGL_NV_cuda_event

130 EGL_NV_depth_nonlinear

131 EGL_NV_device_cuda

132 EGL_NV_native_query

133 EGL_NV_post_convert_rounding

134 EGL_NV_post_sub_buffer

135 EGL_NV_quadruple_buffer

136 EGL_NV_robustness_video_memory_purge

137 EGL_NV_stream_consumer_eglimage

138 EGL_NV_stream_consumer_eglimage_use_scanout_attrib

139 EGL_NV_stream_consumer_gltexture_yuv

140 EGL_NV_stream_cross_display

141 EGL_NV_stream_cross_object

142 EGL_NV_stream_cross_partition

143 EGL_NV_stream_cross_process

144 EGL_NV_stream_cross_system

145 EGL_NV_stream_dma

146 EGL_NV_stream_fifo_next

147 EGL_NV_stream_fifo_synchronous

148 EGL_NV_stream_flush

149 EGL_NV_stream_frame_limits

150 EGL_NV_stream_metadata

151 EGL_NV_stream_origin

152 EGL_NV_stream_remote

153 EGL_NV_stream_reset

154 EGL_NV_stream_socket

155 EGL_NV_stream_socket_inet

156 EGL_NV_stream_socket_unix

157 EGL_NV_stream_sync

158 EGL_NV_sync

159 EGL_NV_system_time

160 EGL_NV_triple_buffer

161 EGL_QNX_image_native_buffer

162 EGL_QNX_platform_screen

163 EGL_TIZEN_image_native_buffer

164 EGL_TIZEN_image_native_surface

165 EGL_WL_bind_wayland_display

166 EGL_WL_create_wayland_buffer_from_image
+ +
+ + diff --git a/doc/glew.html b/doc/glew.html index c1f2ee6..d39b655 100644 --- a/doc/glew.html +++ b/doc/glew.html @@ -1,7 +1,7 @@ @@ -362,694 +359,728 @@ THE POSSIBILITY OF SUCH DAMAGE. 255 ARM_mali_program_binary 256 ARM_mali_shader_binary 257 ARM_rgba8 -258 ARM_shader_framebuffer_fetch -259 ARM_shader_framebuffer_fetch_depth_stencil -260 ARM_texture_unnormalized_coordinates +258 ARM_shader_core_properties +259 ARM_shader_framebuffer_fetch +260 ARM_shader_framebuffer_fetch_depth_stencil +261 ARM_texture_unnormalized_coordinates
-261 ATIX_point_sprites -262 ATIX_texture_env_combine3 -263 ATIX_texture_env_route -264 ATIX_vertex_shader_output_point_size +262 ATIX_point_sprites +263 ATIX_texture_env_combine3 +264 ATIX_texture_env_route +265 ATIX_vertex_shader_output_point_size
-265 ATI_draw_buffers -266 ATI_element_array -267 ATI_envmap_bumpmap -268 ATI_fragment_shader -269 ATI_map_object_buffer -270 ATI_meminfo -271 ATI_pn_triangles -272 ATI_separate_stencil -273 ATI_shader_texture_lod -274 ATI_text_fragment_shader -275 ATI_texture_compression_3dc -276 ATI_texture_env_combine3 -277 ATI_texture_float -278 ATI_texture_mirror_once -279 ATI_vertex_array_object -280 ATI_vertex_attrib_array_object -281 ATI_vertex_streams +266 ATI_draw_buffers +267 ATI_element_array +268 ATI_envmap_bumpmap +269 ATI_fragment_shader +270 ATI_map_object_buffer +271 ATI_meminfo +272 ATI_pn_triangles +273 ATI_separate_stencil +274 ATI_shader_texture_lod +275 ATI_text_fragment_shader +276 ATI_texture_compression_3dc +277 ATI_texture_env_combine3 +278 ATI_texture_float +279 ATI_texture_mirror_once +280 ATI_vertex_array_object +281 ATI_vertex_attrib_array_object +282 ATI_vertex_streams
-282 DMP_program_binary -283 DMP_shader_binary +283 DMP_program_binary +284 DMP_shader_binary
-284 EXT_422_pixels -285 EXT_Cg_shader -286 EXT_EGL_image_array -287 EXT_EGL_image_external_wrap_modes -288 EXT_EGL_image_storage -289 EXT_EGL_sync -290 EXT_YUV_target -291 EXT_abgr -292 EXT_base_instance -293 EXT_bgra -294 EXT_bindable_uniform -295 EXT_blend_color -296 EXT_blend_equation_separate -297 EXT_blend_func_extended -298 EXT_blend_func_separate -299 EXT_blend_logic_op -300 EXT_blend_minmax -301 EXT_blend_subtract -302 EXT_buffer_storage -303 EXT_clear_texture -304 EXT_clip_control -305 EXT_clip_cull_distance -306 EXT_clip_volume_hint -307 EXT_cmyka -308 EXT_color_buffer_float -309 EXT_color_buffer_half_float -310 EXT_color_subtable -311 EXT_compiled_vertex_array -312 EXT_compressed_ETC1_RGB8_sub_texture -313 EXT_conservative_depth -314 EXT_convolution -315 EXT_coordinate_frame -316 EXT_copy_image -317 EXT_copy_texture -318 EXT_cull_vertex -319 EXT_debug_label -320 EXT_debug_marker -321 EXT_depth_bounds_test -322 EXT_depth_clamp -323 EXT_direct_state_access -324 EXT_discard_framebuffer -325 EXT_disjoint_timer_query -326 EXT_draw_buffers -327 EXT_draw_buffers2 -328 EXT_draw_buffers_indexed -329 EXT_draw_elements_base_vertex -330 EXT_draw_instanced -331 EXT_draw_range_elements -332 EXT_draw_transform_feedback -333 EXT_external_buffer -334 EXT_float_blend -335 EXT_fog_coord -336 EXT_frag_depth -337 EXT_fragment_lighting -338 EXT_framebuffer_blit -339 EXT_framebuffer_multisample -340 EXT_framebuffer_multisample_blit_scaled -341 EXT_framebuffer_object -342 EXT_framebuffer_sRGB -343 EXT_geometry_point_size -344 EXT_geometry_shader -345 EXT_geometry_shader4 -346 EXT_gpu_program_parameters -347 EXT_gpu_shader4 -348 EXT_gpu_shader5 -349 EXT_histogram -350 EXT_index_array_formats -351 EXT_index_func -352 EXT_index_material -353 EXT_index_texture -354 EXT_instanced_arrays -355 EXT_light_texture -356 EXT_map_buffer_range -357 EXT_memory_object -358 EXT_memory_object_fd -359 EXT_memory_object_win32 -360 EXT_misc_attribute -361 EXT_multi_draw_arrays -362 EXT_multi_draw_indirect -363 EXT_multiple_textures -364 EXT_multisample -365 EXT_multisample_compatibility -366 EXT_multisampled_render_to_texture -367 EXT_multisampled_render_to_texture2 -368 EXT_multiview_draw_buffers -369 EXT_multiview_tessellation_geometry_shader -370 EXT_multiview_texture_multisample -371 EXT_multiview_timer_query -372 EXT_occlusion_query_boolean -373 EXT_packed_depth_stencil -374 EXT_packed_float -375 EXT_packed_pixels -376 EXT_paletted_texture -377 EXT_pixel_buffer_object -378 EXT_pixel_transform -379 EXT_pixel_transform_color_table -380 EXT_point_parameters -381 EXT_polygon_offset -382 EXT_polygon_offset_clamp -383 EXT_post_depth_coverage -384 EXT_primitive_bounding_box -385 EXT_protected_textures -386 EXT_provoking_vertex -387 EXT_pvrtc_sRGB -388 EXT_raster_multisample -389 EXT_read_format_bgra -390 EXT_render_snorm -391 EXT_rescale_normal -392 EXT_robustness -393 EXT_sRGB -394 EXT_sRGB_write_control -395 EXT_scene_marker -396 EXT_secondary_color -397 EXT_semaphore -398 EXT_semaphore_fd -399 EXT_semaphore_win32 -400 EXT_separate_shader_objects -401 EXT_separate_specular_color -402 EXT_shader_framebuffer_fetch -403 EXT_shader_framebuffer_fetch_non_coherent -404 EXT_shader_group_vote -405 EXT_shader_image_load_formatted -406 EXT_shader_image_load_store -407 EXT_shader_implicit_conversions -408 EXT_shader_integer_mix -409 EXT_shader_io_blocks -410 EXT_shader_non_constant_global_initializers -411 EXT_shader_pixel_local_storage -412 EXT_shader_pixel_local_storage2 -413 EXT_shader_texture_lod -414 EXT_shadow_funcs -415 EXT_shadow_samplers -416 EXT_shared_texture_palette -417 EXT_sparse_texture -418 EXT_sparse_texture2 -419 EXT_static_vertex_array -420 EXT_stencil_clear_tag -421 EXT_stencil_two_side -422 EXT_stencil_wrap -423 EXT_subtexture -424 EXT_tessellation_point_size -425 EXT_tessellation_shader -426 EXT_texture -427 EXT_texture3D -428 EXT_texture_array -429 EXT_texture_border_clamp -430 EXT_texture_buffer -431 EXT_texture_buffer_object -432 EXT_texture_compression_astc_decode_mode -433 EXT_texture_compression_astc_decode_mode_rgb9e5 -434 EXT_texture_compression_bptc -435 EXT_texture_compression_dxt1 -436 EXT_texture_compression_latc -437 EXT_texture_compression_rgtc -438 EXT_texture_compression_s3tc -439 EXT_texture_compression_s3tc_srgb -440 EXT_texture_cube_map -441 EXT_texture_cube_map_array -442 EXT_texture_edge_clamp -443 EXT_texture_env -444 EXT_texture_env_add -445 EXT_texture_env_combine -446 EXT_texture_env_dot3 -447 EXT_texture_filter_anisotropic -448 EXT_texture_filter_minmax -449 EXT_texture_format_BGRA8888 -450 EXT_texture_format_sRGB_override -451 EXT_texture_integer -452 EXT_texture_lod_bias -453 EXT_texture_mirror_clamp -454 EXT_texture_mirror_clamp_to_edge -455 EXT_texture_norm16 -456 EXT_texture_object -457 EXT_texture_perturb_normal -458 EXT_texture_query_lod -459 EXT_texture_rectangle -460 EXT_texture_rg -461 EXT_texture_sRGB -462 EXT_texture_sRGB_R8 -463 EXT_texture_sRGB_RG8 -464 EXT_texture_sRGB_decode -465 EXT_texture_shadow_lod -466 EXT_texture_shared_exponent -467 EXT_texture_snorm -468 EXT_texture_storage -469 EXT_texture_swizzle -470 EXT_texture_type_2_10_10_10_REV -471 EXT_texture_view -472 EXT_timer_query -473 EXT_transform_feedback -474 EXT_unpack_subimage -475 EXT_vertex_array -476 EXT_vertex_array_bgra -477 EXT_vertex_array_setXXX -478 EXT_vertex_attrib_64bit -479 EXT_vertex_shader -480 EXT_vertex_weighting -481 EXT_win32_keyed_mutex -482 EXT_window_rectangles -483 EXT_x11_sync_object +285 EXT_422_pixels +286 EXT_Cg_shader +287 EXT_EGL_image_array +288 EXT_EGL_image_external_wrap_modes +289 EXT_EGL_image_storage +290 EXT_EGL_image_storage_compression +291 EXT_EGL_sync +292 EXT_YUV_target +293 EXT_abgr +294 EXT_base_instance +295 EXT_bgra +296 EXT_bindable_uniform +297 EXT_blend_color +298 EXT_blend_equation_separate +299 EXT_blend_func_extended +300 EXT_blend_func_separate +301 EXT_blend_logic_op +302 EXT_blend_minmax +303 EXT_blend_subtract +304 EXT_buffer_storage +305 EXT_clear_texture +306 EXT_clip_control +307 EXT_clip_cull_distance +308 EXT_clip_volume_hint +309 EXT_cmyka +310 EXT_color_buffer_float +311 EXT_color_buffer_half_float +312 EXT_color_subtable +313 EXT_compiled_vertex_array +314 EXT_compressed_ETC1_RGB8_sub_texture +315 EXT_conservative_depth +316 EXT_convolution +317 EXT_coordinate_frame +318 EXT_copy_image +319 EXT_copy_texture +320 EXT_cull_vertex +321 EXT_debug_label +322 EXT_debug_marker +323 EXT_depth_bounds_test +324 EXT_depth_clamp +325 EXT_direct_state_access +326 EXT_discard_framebuffer +327 EXT_disjoint_timer_query +328 EXT_draw_buffers +329 EXT_draw_buffers2 +330 EXT_draw_buffers_indexed +331 EXT_draw_elements_base_vertex +332 EXT_draw_instanced +333 EXT_draw_range_elements +334 EXT_draw_transform_feedback +335 EXT_external_buffer +336 EXT_float_blend +337 EXT_fog_coord +338 EXT_frag_depth +339 EXT_fragment_lighting +340 EXT_fragment_shading_rate +341 EXT_fragment_shading_rate_attachment +342 EXT_fragment_shading_rate_primitive +343 EXT_framebuffer_blit +344 EXT_framebuffer_blit_layers +345 EXT_framebuffer_multisample +346 EXT_framebuffer_multisample_blit_scaled +347 EXT_framebuffer_object +348 EXT_framebuffer_sRGB +349 EXT_geometry_point_size +350 EXT_geometry_shader +351 EXT_geometry_shader4 +352 EXT_gpu_program_parameters +353 EXT_gpu_shader4 +354 EXT_gpu_shader5 +355 EXT_histogram +356 EXT_index_array_formats +357 EXT_index_func +358 EXT_index_material +359 EXT_index_texture +360 EXT_instanced_arrays +361 EXT_light_texture +362 EXT_map_buffer_range +363 EXT_memory_object +364 EXT_memory_object_fd +365 EXT_memory_object_win32 +366 EXT_mesh_shader +367 EXT_misc_attribute +368 EXT_multi_draw_arrays +369 EXT_multi_draw_indirect +370 EXT_multiple_textures +371 EXT_multisample +372 EXT_multisample_compatibility +373 EXT_multisampled_render_to_texture +374 EXT_multisampled_render_to_texture2 +375 EXT_multiview_draw_buffers +376 EXT_multiview_tessellation_geometry_shader +377 EXT_multiview_texture_multisample +378 EXT_multiview_timer_query +379 EXT_occlusion_query_boolean +380 EXT_packed_depth_stencil +381 EXT_packed_float +382 EXT_packed_pixels +383 EXT_paletted_texture +384 EXT_pixel_buffer_object +385 EXT_pixel_transform +386 EXT_pixel_transform_color_table +387 EXT_point_parameters +388 EXT_polygon_offset +389 EXT_polygon_offset_clamp +390 EXT_post_depth_coverage +391 EXT_primitive_bounding_box +392 EXT_protected_textures +393 EXT_provoking_vertex +394 EXT_pvrtc_sRGB +395 EXT_raster_multisample +396 EXT_read_format_bgra +397 EXT_render_snorm +398 EXT_rescale_normal +399 EXT_robustness +400 EXT_sRGB +401 EXT_sRGB_write_control +402 EXT_scene_marker +403 EXT_secondary_color +404 EXT_semaphore +405 EXT_semaphore_fd +406 EXT_semaphore_win32 +407 EXT_separate_depth_stencil +408 EXT_separate_shader_objects +409 EXT_separate_specular_color +410 EXT_shader_clock +411 EXT_shader_framebuffer_fetch +412 EXT_shader_framebuffer_fetch_non_coherent +413 EXT_shader_group_vote +414 EXT_shader_image_load_formatted +415 EXT_shader_image_load_store +416 EXT_shader_implicit_conversions +417 EXT_shader_integer_mix +418 EXT_shader_io_blocks +419 EXT_shader_non_constant_global_initializers +420 EXT_shader_pixel_local_storage +421 EXT_shader_pixel_local_storage2 +422 EXT_shader_realtime_clock +423 EXT_shader_samples_identical +424 EXT_shader_texture_lod +425 EXT_shader_texture_samples +426 EXT_shadow_funcs +427 EXT_shadow_samplers +428 EXT_shared_texture_palette +429 EXT_sparse_texture +430 EXT_sparse_texture2 +431 EXT_static_vertex_array +432 EXT_stencil_clear_tag +433 EXT_stencil_two_side +434 EXT_stencil_wrap +435 EXT_subtexture +436 EXT_tessellation_point_size +437 EXT_tessellation_shader +438 EXT_texture +439 EXT_texture3D +440 EXT_texture_array +441 EXT_texture_border_clamp +442 EXT_texture_buffer +443 EXT_texture_buffer_object +444 EXT_texture_compression_astc_decode_mode +445 EXT_texture_compression_astc_decode_mode_rgb9e5 +446 EXT_texture_compression_bptc +447 EXT_texture_compression_dxt1 +448 EXT_texture_compression_latc +449 EXT_texture_compression_rgtc +450 EXT_texture_compression_s3tc +451 EXT_texture_compression_s3tc_srgb +452 EXT_texture_cube_map +453 EXT_texture_cube_map_array +454 EXT_texture_edge_clamp +455 EXT_texture_env +456 EXT_texture_env_add +457 EXT_texture_env_combine +458 EXT_texture_env_dot3 +459 EXT_texture_filter_anisotropic +460 EXT_texture_filter_minmax +461 EXT_texture_format_BGRA8888 +462 EXT_texture_format_sRGB_override +463 EXT_texture_integer +464 EXT_texture_lod_bias +465 EXT_texture_mirror_clamp +466 EXT_texture_mirror_clamp_to_edge +467 EXT_texture_norm16 +468 EXT_texture_object +469 EXT_texture_perturb_normal +470 EXT_texture_query_lod +471 EXT_texture_rectangle +472 EXT_texture_rg +473 EXT_texture_sRGB +474 EXT_texture_sRGB_R8 +475 EXT_texture_sRGB_RG8 +476 EXT_texture_sRGB_decode +477 EXT_texture_shadow_lod +478 EXT_texture_shared_exponent +479 EXT_texture_snorm +480 EXT_texture_storage +481 EXT_texture_storage_compression +482 EXT_texture_swizzle +483 EXT_texture_type_2_10_10_10_REV +484 EXT_texture_view +485 EXT_timer_query +486 EXT_transform_feedback +487 EXT_unpack_subimage +488 EXT_vertex_array +489 EXT_vertex_array_bgra +490 EXT_vertex_array_setXXX +491 EXT_vertex_attrib_64bit +492 EXT_vertex_shader +493 EXT_vertex_weighting +494 EXT_win32_keyed_mutex +495 EXT_window_rectangles +496 EXT_x11_sync_object
-484 FJ_shader_binary_GCCSO +497 FJ_shader_binary_GCCSO
-485 GREMEDY_frame_terminator -486 GREMEDY_string_marker +498 GREMEDY_frame_terminator +499 GREMEDY_string_marker
-487 HP_convolution_border_modes -488 HP_image_transform -489 HP_occlusion_test -490 HP_texture_lighting +500 HP_convolution_border_modes +501 HP_image_transform +502 HP_occlusion_test +503 HP_texture_lighting
-491 IBM_cull_vertex -492 IBM_multimode_draw_arrays -493 IBM_rasterpos_clip -494 IBM_static_data -495 IBM_texture_mirrored_repeat -496 IBM_vertex_array_lists +504 HUAWEI_program_binary +505 HUAWEI_shader_binary
-497 IMG_bindless_texture -498 IMG_framebuffer_downsample -499 IMG_multisampled_render_to_texture -500 IMG_program_binary -501 IMG_read_format -502 IMG_shader_binary -503 IMG_texture_compression_pvrtc -504 IMG_texture_compression_pvrtc2 -505 IMG_texture_env_enhanced_fixed_function -506 IMG_texture_filter_cubic +506 IBM_cull_vertex +507 IBM_multimode_draw_arrays +508 IBM_rasterpos_clip +509 IBM_static_data +510 IBM_texture_mirrored_repeat +511 IBM_vertex_array_lists
-507 INGR_color_clamp -508 INGR_interlace_read +512 IMG_bindless_texture +513 IMG_framebuffer_downsample +514 IMG_multisampled_render_to_texture +515 IMG_program_binary +516 IMG_pvric_end_to_end_signature +517 IMG_read_format +518 IMG_shader_binary +519 IMG_texture_compression_pvrtc +520 IMG_texture_compression_pvrtc2 +521 IMG_texture_env_enhanced_fixed_function +522 IMG_texture_filter_cubic +523 IMG_tile_region_protection
-509 INTEL_blackhole_render -510 INTEL_conservative_rasterization -511 INTEL_fragment_shader_ordering -512 INTEL_framebuffer_CMAA -513 INTEL_map_texture -514 INTEL_parallel_arrays -515 INTEL_performance_query -516 INTEL_shader_integer_functions2 -517 INTEL_texture_scissor +524 INGR_color_clamp +525 INGR_interlace_read
-518 KHR_blend_equation_advanced -519 KHR_blend_equation_advanced_coherent -520 KHR_context_flush_control -521 KHR_debug -522 KHR_no_error -523 KHR_parallel_shader_compile -524 KHR_robust_buffer_access_behavior -525 KHR_robustness -526 KHR_shader_subgroup -527 KHR_texture_compression_astc_hdr -528 KHR_texture_compression_astc_ldr -529 KHR_texture_compression_astc_sliced_3d +526 INTEL_blackhole_render +527 INTEL_conservative_rasterization +528 INTEL_fragment_shader_ordering +529 INTEL_framebuffer_CMAA +530 INTEL_map_texture +531 INTEL_parallel_arrays +532 INTEL_performance_query +533 INTEL_shader_integer_functions2 +534 INTEL_texture_scissor
-530 KTX_buffer_region +535 KHR_blend_equation_advanced +536 KHR_blend_equation_advanced_coherent +537 KHR_context_flush_control +538 KHR_debug +539 KHR_no_error +540 KHR_parallel_shader_compile +541 KHR_robust_buffer_access_behavior +542 KHR_robustness +543 KHR_shader_subgroup +544 KHR_texture_compression_astc_hdr +545 KHR_texture_compression_astc_ldr +546 KHR_texture_compression_astc_sliced_3d
-531 MESAX_texture_stack +547 KTX_buffer_region
-532 MESA_framebuffer_flip_y -533 MESA_pack_invert -534 MESA_program_binary_formats -535 MESA_resize_buffers -536 MESA_shader_integer_functions -537 MESA_tile_raster_order -538 MESA_window_pos -539 MESA_ycbcr_texture +548 MESAX_texture_stack
-540 NVX_blend_equation_advanced_multi_draw_buffers -541 NVX_conditional_render -542 NVX_gpu_memory_info -543 NVX_gpu_multicast2 -544 NVX_linked_gpu_multicast -545 NVX_progress_fence +549 MESA_bgra +550 MESA_framebuffer_flip_x +551 MESA_framebuffer_flip_y +552 MESA_framebuffer_swap_xy +553 MESA_pack_invert +554 MESA_program_binary_formats +555 MESA_resize_buffers +556 MESA_shader_integer_functions +557 MESA_texture_const_bandwidth +558 MESA_tile_raster_order +559 MESA_window_pos +560 MESA_ycbcr_texture
-546 NV_3dvision_settings -547 NV_EGL_stream_consumer_external -548 NV_alpha_to_coverage_dither_control -549 NV_bgr -550 NV_bindless_multi_draw_indirect -551 NV_bindless_multi_draw_indirect_count -552 NV_bindless_texture -553 NV_blend_equation_advanced -554 NV_blend_equation_advanced_coherent -555 NV_blend_minmax_factor -556 NV_blend_square -557 NV_clip_space_w_scaling -558 NV_command_list -559 NV_compute_program5 -560 NV_compute_shader_derivatives -561 NV_conditional_render -562 NV_conservative_raster -563 NV_conservative_raster_dilate -564 NV_conservative_raster_pre_snap -565 NV_conservative_raster_pre_snap_triangles -566 NV_conservative_raster_underestimation -567 NV_copy_buffer -568 NV_copy_depth_to_color -569 NV_copy_image -570 NV_deep_texture3D -571 NV_depth_buffer_float -572 NV_depth_clamp -573 NV_depth_nonlinear -574 NV_depth_range_unclamped -575 NV_draw_buffers -576 NV_draw_instanced -577 NV_draw_texture -578 NV_draw_vulkan_image -579 NV_evaluators -580 NV_explicit_attrib_location -581 NV_explicit_multisample -582 NV_fbo_color_attachments -583 NV_fence -584 NV_fill_rectangle -585 NV_float_buffer -586 NV_fog_distance -587 NV_fragment_coverage_to_color -588 NV_fragment_program -589 NV_fragment_program2 -590 NV_fragment_program4 -591 NV_fragment_program_option -592 NV_fragment_shader_barycentric -593 NV_fragment_shader_interlock -594 NV_framebuffer_blit -595 NV_framebuffer_mixed_samples -596 NV_framebuffer_multisample -597 NV_framebuffer_multisample_coverage -598 NV_generate_mipmap_sRGB -599 NV_geometry_program4 -600 NV_geometry_shader4 -601 NV_geometry_shader_passthrough -602 NV_gpu_multicast -603 NV_gpu_program4 -604 NV_gpu_program5 -605 NV_gpu_program5_mem_extended -606 NV_gpu_program_fp64 -607 NV_gpu_shader5 -608 NV_half_float -609 NV_image_formats -610 NV_instanced_arrays -611 NV_internalformat_sample_query -612 NV_light_max_exponent -613 NV_memory_attachment -614 NV_mesh_shader -615 NV_multisample_coverage -616 NV_multisample_filter_hint -617 NV_non_square_matrices -618 NV_occlusion_query -619 NV_pack_subimage -620 NV_packed_depth_stencil -621 NV_packed_float -622 NV_packed_float_linear -623 NV_parameter_buffer_object -624 NV_parameter_buffer_object2 -625 NV_path_rendering -626 NV_path_rendering_shared_edge -627 NV_pixel_buffer_object -628 NV_pixel_data_range -629 NV_platform_binary -630 NV_point_sprite -631 NV_polygon_mode -632 NV_present_video -633 NV_primitive_restart -634 NV_query_resource_tag -635 NV_read_buffer -636 NV_read_buffer_front -637 NV_read_depth -638 NV_read_depth_stencil -639 NV_read_stencil -640 NV_register_combiners -641 NV_register_combiners2 -642 NV_representative_fragment_test -643 NV_robustness_video_memory_purge -644 NV_sRGB_formats -645 NV_sample_locations -646 NV_sample_mask_override_coverage -647 NV_scissor_exclusive -648 NV_shader_atomic_counters -649 NV_shader_atomic_float -650 NV_shader_atomic_float64 -651 NV_shader_atomic_fp16_vector -652 NV_shader_atomic_int64 -653 NV_shader_buffer_load -654 NV_shader_noperspective_interpolation -655 NV_shader_storage_buffer_object -656 NV_shader_subgroup_partitioned -657 NV_shader_texture_footprint -658 NV_shader_thread_group -659 NV_shader_thread_shuffle -660 NV_shading_rate_image -661 NV_shadow_samplers_array -662 NV_shadow_samplers_cube -663 NV_stereo_view_rendering -664 NV_tessellation_program5 -665 NV_texgen_emboss -666 NV_texgen_reflection -667 NV_texture_array -668 NV_texture_barrier -669 NV_texture_border_clamp -670 NV_texture_compression_latc -671 NV_texture_compression_s3tc -672 NV_texture_compression_s3tc_update -673 NV_texture_compression_vtc -674 NV_texture_env_combine4 -675 NV_texture_expand_normal -676 NV_texture_multisample -677 NV_texture_npot_2D_mipmap -678 NV_texture_rectangle -679 NV_texture_rectangle_compressed -680 NV_texture_shader -681 NV_texture_shader2 -682 NV_texture_shader3 -683 NV_transform_feedback -684 NV_transform_feedback2 -685 NV_uniform_buffer_unified_memory -686 NV_vdpau_interop -687 NV_vdpau_interop2 -688 NV_vertex_array_range -689 NV_vertex_array_range2 -690 NV_vertex_attrib_integer_64bit -691 NV_vertex_buffer_unified_memory -692 NV_vertex_program -693 NV_vertex_program1_1 -694 NV_vertex_program2 -695 NV_vertex_program2_option -696 NV_vertex_program3 -697 NV_vertex_program4 -698 NV_video_capture -699 NV_viewport_array -700 NV_viewport_array2 -701 NV_viewport_swizzle +561 NVX_blend_equation_advanced_multi_draw_buffers +562 NVX_conditional_render +563 NVX_gpu_memory_info +564 NVX_gpu_multicast2 +565 NVX_linked_gpu_multicast +566 NVX_progress_fence
-702 OES_EGL_image -703 OES_EGL_image_external -704 OES_EGL_image_external_essl3 -705 OES_blend_equation_separate -706 OES_blend_func_separate -707 OES_blend_subtract -708 OES_byte_coordinates -709 OES_compressed_ETC1_RGB8_texture -710 OES_compressed_paletted_texture -711 OES_copy_image -712 OES_depth24 -713 OES_depth32 -714 OES_depth_texture -715 OES_depth_texture_cube_map -716 OES_draw_buffers_indexed -717 OES_draw_texture -718 OES_element_index_uint -719 OES_extended_matrix_palette -720 OES_fbo_render_mipmap -721 OES_fragment_precision_high -722 OES_framebuffer_object -723 OES_geometry_point_size -724 OES_geometry_shader -725 OES_get_program_binary -726 OES_gpu_shader5 -727 OES_mapbuffer -728 OES_matrix_get -729 OES_matrix_palette -730 OES_packed_depth_stencil -731 OES_point_size_array -732 OES_point_sprite -733 OES_read_format -734 OES_required_internalformat -735 OES_rgb8_rgba8 -736 OES_sample_shading -737 OES_sample_variables -738 OES_shader_image_atomic -739 OES_shader_io_blocks -740 OES_shader_multisample_interpolation -741 OES_single_precision -742 OES_standard_derivatives -743 OES_stencil1 -744 OES_stencil4 -745 OES_stencil8 -746 OES_surfaceless_context -747 OES_tessellation_point_size -748 OES_tessellation_shader -749 OES_texture_3D -750 OES_texture_border_clamp -751 OES_texture_buffer -752 OES_texture_compression_astc -753 OES_texture_cube_map -754 OES_texture_cube_map_array -755 OES_texture_env_crossbar -756 OES_texture_mirrored_repeat -757 OES_texture_npot -758 OES_texture_stencil8 -759 OES_texture_storage_multisample_2d_array -760 OES_texture_view -761 OES_vertex_array_object -762 OES_vertex_half_float -763 OES_vertex_type_10_10_10_2 +567 NV_3dvision_settings +568 NV_EGL_stream_consumer_external +569 NV_alpha_to_coverage_dither_control +570 NV_bgr +571 NV_bindless_multi_draw_indirect +572 NV_bindless_multi_draw_indirect_count +573 NV_bindless_texture +574 NV_blend_equation_advanced +575 NV_blend_equation_advanced_coherent +576 NV_blend_minmax_factor +577 NV_blend_square +578 NV_clip_space_w_scaling +579 NV_command_list +580 NV_compute_program5 +581 NV_compute_shader_derivatives +582 NV_conditional_render +583 NV_conservative_raster +584 NV_conservative_raster_dilate +585 NV_conservative_raster_pre_snap +586 NV_conservative_raster_pre_snap_triangles +587 NV_conservative_raster_underestimation +588 NV_copy_buffer +589 NV_copy_depth_to_color +590 NV_copy_image +591 NV_deep_texture3D +592 NV_depth_buffer_float +593 NV_depth_clamp +594 NV_depth_nonlinear +595 NV_depth_range_unclamped +596 NV_draw_buffers +597 NV_draw_instanced +598 NV_draw_texture +599 NV_draw_vulkan_image +600 NV_evaluators +601 NV_explicit_attrib_location +602 NV_explicit_multisample +603 NV_fbo_color_attachments +604 NV_fence +605 NV_fill_rectangle +606 NV_float_buffer +607 NV_fog_distance +608 NV_fragment_coverage_to_color +609 NV_fragment_program +610 NV_fragment_program2 +611 NV_fragment_program4 +612 NV_fragment_program_option +613 NV_fragment_shader_barycentric +614 NV_fragment_shader_interlock +615 NV_framebuffer_blit +616 NV_framebuffer_mixed_samples +617 NV_framebuffer_multisample +618 NV_framebuffer_multisample_coverage +619 NV_generate_mipmap_sRGB +620 NV_geometry_program4 +621 NV_geometry_shader4 +622 NV_geometry_shader_passthrough +623 NV_gpu_multicast +624 NV_gpu_program4 +625 NV_gpu_program5 +626 NV_gpu_program5_mem_extended +627 NV_gpu_program_fp64 +628 NV_gpu_shader5 +629 NV_half_float +630 NV_image_formats +631 NV_instanced_arrays +632 NV_internalformat_sample_query +633 NV_light_max_exponent +634 NV_memory_attachment +635 NV_memory_object_sparse +636 NV_mesh_shader +637 NV_multisample_coverage +638 NV_multisample_filter_hint +639 NV_non_square_matrices +640 NV_occlusion_query +641 NV_pack_subimage +642 NV_packed_depth_stencil +643 NV_packed_float +644 NV_packed_float_linear +645 NV_parameter_buffer_object +646 NV_parameter_buffer_object2 +647 NV_path_rendering +648 NV_path_rendering_shared_edge +649 NV_pixel_buffer_object +650 NV_pixel_data_range +651 NV_platform_binary +652 NV_point_sprite +653 NV_polygon_mode +654 NV_present_video +655 NV_primitive_restart +656 NV_primitive_shading_rate +657 NV_query_resource_tag +658 NV_read_buffer +659 NV_read_buffer_front +660 NV_read_depth +661 NV_read_depth_stencil +662 NV_read_stencil +663 NV_register_combiners +664 NV_register_combiners2 +665 NV_representative_fragment_test +666 NV_robustness_video_memory_purge +667 NV_sRGB_formats +668 NV_sample_locations +669 NV_sample_mask_override_coverage +670 NV_scissor_exclusive +671 NV_shader_atomic_counters +672 NV_shader_atomic_float +673 NV_shader_atomic_float64 +674 NV_shader_atomic_fp16_vector +675 NV_shader_atomic_int64 +676 NV_shader_buffer_load +677 NV_shader_noperspective_interpolation +678 NV_shader_storage_buffer_object +679 NV_shader_subgroup_partitioned +680 NV_shader_texture_footprint +681 NV_shader_thread_group +682 NV_shader_thread_shuffle +683 NV_shading_rate_image +684 NV_shadow_samplers_array +685 NV_shadow_samplers_cube +686 NV_stereo_view_rendering +687 NV_tessellation_program5 +688 NV_texgen_emboss +689 NV_texgen_reflection +690 NV_texture_array +691 NV_texture_barrier +692 NV_texture_border_clamp +693 NV_texture_compression_latc +694 NV_texture_compression_s3tc +695 NV_texture_compression_s3tc_update +696 NV_texture_compression_vtc +697 NV_texture_env_combine4 +698 NV_texture_expand_normal +699 NV_texture_multisample +700 NV_texture_npot_2D_mipmap +701 NV_texture_rectangle +702 NV_texture_rectangle_compressed +703 NV_texture_shader +704 NV_texture_shader2 +705 NV_texture_shader3 +706 NV_timeline_semaphore +707 NV_transform_feedback +708 NV_transform_feedback2 +709 NV_uniform_buffer_std430_layout +710 NV_uniform_buffer_unified_memory +711 NV_vdpau_interop +712 NV_vdpau_interop2 +713 NV_vertex_array_range +714 NV_vertex_array_range2 +715 NV_vertex_attrib_integer_64bit +716 NV_vertex_buffer_unified_memory +717 NV_vertex_program +718 NV_vertex_program1_1 +719 NV_vertex_program2 +720 NV_vertex_program2_option +721 NV_vertex_program3 +722 NV_vertex_program4 +723 NV_video_capture +724 NV_viewport_array +725 NV_viewport_array2 +726 NV_viewport_swizzle
-764 OML_interlace -765 OML_resample -766 OML_subsample +727 OES_EGL_image +728 OES_EGL_image_external +729 OES_EGL_image_external_essl3 +730 OES_blend_equation_separate +731 OES_blend_func_separate +732 OES_blend_subtract +733 OES_byte_coordinates +734 OES_compressed_ETC1_RGB8_texture +735 OES_compressed_paletted_texture +736 OES_copy_image +737 OES_depth24 +738 OES_depth32 +739 OES_depth_texture +740 OES_depth_texture_cube_map +741 OES_draw_buffers_indexed +742 OES_draw_texture +743 OES_element_index_uint +744 OES_extended_matrix_palette +745 OES_fbo_render_mipmap +746 OES_fragment_precision_high +747 OES_framebuffer_object +748 OES_geometry_point_size +749 OES_geometry_shader +750 OES_get_program_binary +751 OES_gpu_shader5 +752 OES_mapbuffer +753 OES_matrix_get +754 OES_matrix_palette +755 OES_packed_depth_stencil +756 OES_point_size_array +757 OES_point_sprite +758 OES_read_format +759 OES_required_internalformat +760 OES_rgb8_rgba8 +761 OES_sample_shading +762 OES_sample_variables +763 OES_shader_image_atomic +764 OES_shader_io_blocks +765 OES_shader_multisample_interpolation +766 OES_single_precision +767 OES_standard_derivatives +768 OES_stencil1 +769 OES_stencil4 +770 OES_stencil8 +771 OES_surfaceless_context +772 OES_tessellation_point_size +773 OES_tessellation_shader +774 OES_texture_3D +775 OES_texture_border_clamp +776 OES_texture_buffer +777 OES_texture_compression_astc +778 OES_texture_cube_map +779 OES_texture_cube_map_array +780 OES_texture_env_crossbar +781 OES_texture_mirrored_repeat +782 OES_texture_npot +783 OES_texture_stencil8 +784 OES_texture_storage_multisample_2d_array +785 OES_texture_view +786 OES_vertex_array_object +787 OES_vertex_half_float +788 OES_vertex_type_10_10_10_2
-767 OVR_multiview -768 OVR_multiview2 -769 OVR_multiview_multisampled_render_to_texture +789 OML_interlace +790 OML_resample +791 OML_subsample
-770 PGI_misc_hints -771 PGI_vertex_hints +792 OVR_multiview +793 OVR_multiview2 +794 OVR_multiview_multisampled_render_to_texture
-772 QCOM_YUV_texture_gather -773 QCOM_alpha_test -774 QCOM_binning_control -775 QCOM_driver_control -776 QCOM_extended_get -777 QCOM_extended_get2 -778 QCOM_framebuffer_foveated -779 QCOM_perfmon_global_mode -780 QCOM_shader_framebuffer_fetch_noncoherent -781 QCOM_shader_framebuffer_fetch_rate -782 QCOM_texture_foveated -783 QCOM_texture_foveated_subsampled_layout -784 QCOM_tiled_rendering -785 QCOM_writeonly_rendering +795 PGI_misc_hints +796 PGI_vertex_hints
-786 REGAL_ES1_0_compatibility -787 REGAL_ES1_1_compatibility -788 REGAL_enable -789 REGAL_error_string -790 REGAL_extension_query -791 REGAL_log -792 REGAL_proc_address +797 QCOM_YUV_texture_gather +798 QCOM_alpha_test +799 QCOM_binning_control +800 QCOM_driver_control +801 QCOM_extended_get +802 QCOM_extended_get2 +803 QCOM_frame_extrapolation +804 QCOM_framebuffer_foveated +805 QCOM_motion_estimation +806 QCOM_perfmon_global_mode +807 QCOM_render_sRGB_R8_RG8 +808 QCOM_render_shared_exponent +809 QCOM_shader_framebuffer_fetch_noncoherent +810 QCOM_shader_framebuffer_fetch_rate +811 QCOM_shading_rate +812 QCOM_texture_foveated +813 QCOM_texture_foveated2 +814 QCOM_texture_foveated_subsampled_layout +815 QCOM_texture_lod_bias +816 QCOM_tiled_rendering +817 QCOM_writeonly_rendering +818 QCOM_ycbcr_degamma
-793 REND_screen_coordinates +819 REGAL_ES1_0_compatibility +820 REGAL_ES1_1_compatibility +821 REGAL_enable +822 REGAL_error_string +823 REGAL_extension_query +824 REGAL_log +825 REGAL_proc_address
-794 S3_s3tc +826 REND_screen_coordinates
-795 SGIS_clip_band_hint -796 SGIS_color_range -797 SGIS_detail_texture -798 SGIS_fog_function -799 SGIS_generate_mipmap -800 SGIS_line_texgen -801 SGIS_multisample -802 SGIS_multitexture -803 SGIS_pixel_texture -804 SGIS_point_line_texgen -805 SGIS_shared_multisample -806 SGIS_sharpen_texture -807 SGIS_texture4D -808 SGIS_texture_border_clamp -809 SGIS_texture_edge_clamp -810 SGIS_texture_filter4 -811 SGIS_texture_lod -812 SGIS_texture_select +827 S3_s3tc
-813 SGIX_async -814 SGIX_async_histogram -815 SGIX_async_pixel -816 SGIX_bali_g_instruments -817 SGIX_bali_r_instruments -818 SGIX_bali_timer_instruments -819 SGIX_blend_alpha_minmax -820 SGIX_blend_cadd -821 SGIX_blend_cmultiply -822 SGIX_calligraphic_fragment -823 SGIX_clipmap -824 SGIX_color_matrix_accuracy -825 SGIX_color_table_index_mode -826 SGIX_complex_polar -827 SGIX_convolution_accuracy -828 SGIX_cube_map -829 SGIX_cylinder_texgen -830 SGIX_datapipe -831 SGIX_decimation -832 SGIX_depth_pass_instrument -833 SGIX_depth_texture -834 SGIX_dvc -835 SGIX_flush_raster -836 SGIX_fog_blend -837 SGIX_fog_factor_to_alpha -838 SGIX_fog_layers -839 SGIX_fog_offset -840 SGIX_fog_patchy -841 SGIX_fog_scale -842 SGIX_fog_texture -843 SGIX_fragment_lighting_space -844 SGIX_fragment_specular_lighting -845 SGIX_fragments_instrument -846 SGIX_framezoom -847 SGIX_icc_texture -848 SGIX_igloo_interface -849 SGIX_image_compression -850 SGIX_impact_pixel_texture -851 SGIX_instrument_error -852 SGIX_interlace -853 SGIX_ir_instrument1 -854 SGIX_line_quality_hint -855 SGIX_list_priority -856 SGIX_mpeg1 -857 SGIX_mpeg2 -858 SGIX_nonlinear_lighting_pervertex -859 SGIX_nurbs_eval -860 SGIX_occlusion_instrument -861 SGIX_packed_6bytes -862 SGIX_pixel_texture -863 SGIX_pixel_texture_bits -864 SGIX_pixel_texture_lod -865 SGIX_pixel_tiles -866 SGIX_polynomial_ffd -867 SGIX_quad_mesh -868 SGIX_reference_plane -869 SGIX_resample -870 SGIX_scalebias_hint -871 SGIX_shadow -872 SGIX_shadow_ambient -873 SGIX_slim -874 SGIX_spotlight_cutoff -875 SGIX_sprite -876 SGIX_subdiv_patch -877 SGIX_subsample -878 SGIX_tag_sample_buffer -879 SGIX_texture_add_env -880 SGIX_texture_coordinate_clamp -881 SGIX_texture_lod_bias -882 SGIX_texture_mipmap_anisotropic -883 SGIX_texture_multi_buffer -884 SGIX_texture_phase -885 SGIX_texture_range -886 SGIX_texture_scale_bias -887 SGIX_texture_supersample -888 SGIX_vector_ops -889 SGIX_vertex_array_object -890 SGIX_vertex_preclip -891 SGIX_vertex_preclip_hint -892 SGIX_ycrcb -893 SGIX_ycrcb_subsample -894 SGIX_ycrcba +828 SGIS_clip_band_hint +829 SGIS_color_range +830 SGIS_detail_texture +831 SGIS_fog_function +832 SGIS_generate_mipmap +833 SGIS_line_texgen +834 SGIS_multisample +835 SGIS_multitexture +836 SGIS_pixel_texture +837 SGIS_point_line_texgen +838 SGIS_shared_multisample +839 SGIS_sharpen_texture +840 SGIS_texture4D +841 SGIS_texture_border_clamp +842 SGIS_texture_edge_clamp +843 SGIS_texture_filter4 +844 SGIS_texture_lod +845 SGIS_texture_select
-895 SGI_color_matrix -896 SGI_color_table -897 SGI_complex -898 SGI_complex_type -899 SGI_fft -900 SGI_texture_color_table +846 SGIX_async +847 SGIX_async_histogram +848 SGIX_async_pixel +849 SGIX_bali_g_instruments +850 SGIX_bali_r_instruments +851 SGIX_bali_timer_instruments +852 SGIX_blend_alpha_minmax +853 SGIX_blend_cadd +854 SGIX_blend_cmultiply +855 SGIX_calligraphic_fragment +856 SGIX_clipmap +857 SGIX_color_matrix_accuracy +858 SGIX_color_table_index_mode +859 SGIX_complex_polar +860 SGIX_convolution_accuracy +861 SGIX_cube_map +862 SGIX_cylinder_texgen +863 SGIX_datapipe +864 SGIX_decimation +865 SGIX_depth_pass_instrument +866 SGIX_depth_texture +867 SGIX_dvc +868 SGIX_flush_raster +869 SGIX_fog_blend +870 SGIX_fog_factor_to_alpha +871 SGIX_fog_layers +872 SGIX_fog_offset +873 SGIX_fog_patchy +874 SGIX_fog_scale +875 SGIX_fog_texture +876 SGIX_fragment_lighting_space +877 SGIX_fragment_specular_lighting +878 SGIX_fragments_instrument +879 SGIX_framezoom +880 SGIX_icc_texture +881 SGIX_igloo_interface +882 SGIX_image_compression +883 SGIX_impact_pixel_texture +884 SGIX_instrument_error +885 SGIX_interlace +886 SGIX_ir_instrument1 +887 SGIX_line_quality_hint +888 SGIX_list_priority +889 SGIX_mpeg1 +890 SGIX_mpeg2 +891 SGIX_nonlinear_lighting_pervertex +892 SGIX_nurbs_eval +893 SGIX_occlusion_instrument +894 SGIX_packed_6bytes +895 SGIX_pixel_texture +896 SGIX_pixel_texture_bits +897 SGIX_pixel_texture_lod +898 SGIX_pixel_tiles +899 SGIX_polynomial_ffd +900 SGIX_quad_mesh +901 SGIX_reference_plane +902 SGIX_resample +903 SGIX_scalebias_hint +904 SGIX_shadow +905 SGIX_shadow_ambient +906 SGIX_slim +907 SGIX_spotlight_cutoff +908 SGIX_sprite +909 SGIX_subdiv_patch +910 SGIX_subsample +911 SGIX_tag_sample_buffer +912 SGIX_texture_add_env +913 SGIX_texture_coordinate_clamp +914 SGIX_texture_lod_bias +915 SGIX_texture_mipmap_anisotropic +916 SGIX_texture_multi_buffer +917 SGIX_texture_phase +918 SGIX_texture_range +919 SGIX_texture_scale_bias +920 SGIX_texture_supersample +921 SGIX_vector_ops +922 SGIX_vertex_array_object +923 SGIX_vertex_preclip +924 SGIX_vertex_preclip_hint +925 SGIX_ycrcb +926 SGIX_ycrcb_subsample +927 SGIX_ycrcba
-901 SUNX_constant_data +928 SGI_color_matrix +929 SGI_color_table +930 SGI_complex +931 SGI_complex_type +932 SGI_fft +933 SGI_texture_color_table
-902 SUN_convolution_border_modes -903 SUN_global_alpha -904 SUN_mesh_array -905 SUN_read_video_pixels -906 SUN_slice_accum -907 SUN_triangle_list -908 SUN_vertex +934 SUNX_constant_data
-909 VIV_shader_binary +935 SUN_convolution_border_modes +936 SUN_global_alpha +937 SUN_mesh_array +938 SUN_read_video_pixels +939 SUN_slice_accum +940 SUN_triangle_list +941 SUN_vertex
-910 WIN_phong_shading -911 WIN_scene_markerXXX -912 WIN_specular_fog -913 WIN_swap_hint +942 VIV_shader_binary +
+943 WIN_phong_shading +944 WIN_scene_markerXXX +945 WIN_specular_fog +946 WIN_swap_hint diff --git a/doc/glxew.html b/doc/glxew.html index 0063c89..f32d1bb 100644 --- a/doc/glxew.html +++ b/doc/glxew.html @@ -1,7 +1,7 @@ @@ -125,63 +122,64 @@ THE POSSIBILITY OF SUCH DAMAGE. 20 EXT_create_context_es_profile 21 EXT_fbconfig_packed_float 22 EXT_framebuffer_sRGB -23 EXT_import_context -24 EXT_libglvnd -25 EXT_no_config_context -26 EXT_scene_marker -27 EXT_stereo_tree -28 EXT_swap_control -29 EXT_swap_control_tear -30 EXT_texture_from_pixmap -31 EXT_visual_info -32 EXT_visual_rating +23 EXT_get_drawable_type +24 EXT_import_context +25 EXT_libglvnd +26 EXT_no_config_context +27 EXT_scene_marker +28 EXT_stereo_tree +29 EXT_swap_control +30 EXT_swap_control_tear +31 EXT_texture_from_pixmap +32 EXT_visual_info +33 EXT_visual_rating
-33 INTEL_swap_event +34 INTEL_swap_event
-34 MESA_agp_offset -35 MESA_copy_sub_buffer -36 MESA_pixmap_colormap -37 MESA_query_renderer -38 MESA_release_buffers -39 MESA_set_3dfx_mode -40 MESA_swap_control +35 MESA_agp_offset +36 MESA_copy_sub_buffer +37 MESA_pixmap_colormap +38 MESA_query_renderer +39 MESA_release_buffers +40 MESA_set_3dfx_mode +41 MESA_swap_control
-41 NV_copy_buffer -42 NV_copy_image -43 NV_delay_before_swap -44 NV_float_buffer -45 NV_multigpu_context -46 NV_multisample_coverage -47 NV_present_video -48 NV_robustness_video_memory_purge -49 NV_swap_group -50 NV_vertex_array_range -51 NV_video_capture -52 NV_video_out +42 NV_copy_buffer +43 NV_copy_image +44 NV_delay_before_swap +45 NV_float_buffer +46 NV_multigpu_context +47 NV_multisample_coverage +48 NV_present_video +49 NV_robustness_video_memory_purge +50 NV_swap_group +51 NV_vertex_array_range +52 NV_video_capture +53 NV_video_out
-53 OML_swap_method -54 OML_sync_control +54 OML_swap_method +55 OML_sync_control
-55 SGIS_blended_overlay -56 SGIS_color_range -57 SGIS_multisample -58 SGIS_shared_multisample +56 SGIS_blended_overlay +57 SGIS_color_range +58 SGIS_multisample +59 SGIS_shared_multisample
-59 SGIX_fbconfig -60 SGIX_hyperpipe -61 SGIX_pbuffer -62 SGIX_swap_barrier -63 SGIX_swap_group -64 SGIX_video_resize -65 SGIX_visual_select_group +60 SGIX_fbconfig +61 SGIX_hyperpipe +62 SGIX_pbuffer +63 SGIX_swap_barrier +64 SGIX_swap_group +65 SGIX_video_resize +66 SGIX_visual_select_group
-66 SGI_cushion -67 SGI_make_current_read -68 SGI_swap_control -69 SGI_video_sync +67 SGI_cushion +68 SGI_make_current_read +69 SGI_swap_control +70 SGI_video_sync
-70 SUN_get_transparent_index -71 SUN_video_resize +71 SUN_get_transparent_index +72 SUN_video_resize diff --git a/doc/index.html b/doc/index.html index c8fb66d..c696a4b 100644 --- a/doc/index.html +++ b/doc/index.html @@ -1,7 +1,7 @@ @@ -108,10 +105,10 @@ Mac OS X, FreeBSD, Irix, and Solaris.

Downloads

-GLEW is distributed +GLEW is distributed as source and precompiled binaries.
The latest release is -2.2.0[03-15-20]: +2.3.0[12-27-2025]:

@@ -125,8 +122,8 @@ The latest release is Source -ZIP |  -TGZ +ZIP |  +TGZ @@ -134,7 +131,7 @@ The latest release is Binaries -Windows 32-bit and 64-bit +Windows 32-bit and 64-bit @@ -159,45 +156,47 @@ The latest release contains support for OpenGL 4.6, compatibility and forward-co
  • OpenGL extensions
  • WGL extensions
  • GLX extensions +
  • EGL extensions

    News

      -
    • [03-15-20] GLEW 2.2.0 new extensions and minor bug fixes
      • -
    • [07-31-17] GLEW 2.1.0 adds support for OpenGL 4.6, new extensions and minor bug fixes
      • -
    • [07-24-16] GLEW 2.0.0 adds support for forward-compatible contexts, adds new extensions, OSMesa and EGL support, MX discontinued and minor bug fixes
      • -
    • [08-10-15] GLEW 1.13.0 adds support for new extensions, fixes minor bugs
      • -
    • [26-01-15] GLEW 1.12.0 fixes minor bugs and adds new extensions
      • -
    • [08-11-14] GLEW 1.11.0 adds support for OpenGL 4.5, new extensions
      • -
    • [07-22-13] GLEW 1.10.0 adds support for OpenGL 4.4, new extensions
      • -
    • [08-06-12] GLEW 1.9.0 adds support for OpenGL 4.3, new extensions
      • -
    • [07-17-12] GLEW 1.8.0 fixes minor bugs and adds new extensions
      • -
    • [08-26-11] GLEW 1.7.0 adds support for OpenGL 4.2, new extensions, fixes bugs
      • -
    • [04-27-11] GLEW 1.6.0 fixes minor bugs and adds eight new extensions
      • -
    • [01-31-11] GLEW 1.5.8 fixes minor bugs and adds two new extensions
      • -
    • [11-03-10] GLEW 1.5.7 fixes minor bugs and adds one new extension
      • -
    • [09-07-10] GLEW 1.5.6 adds support for OpenGL 4.1, fixes bugs
      • -
    • [07-13-10] GLEW 1.5.5 fixes minor bugs and adds new extensions
      • -
    • [04-21-10] GLEW 1.5.4 adds support for OpenGL 3.3, OpenGL 4.0 and new extensions, fixes bugs
      • -
    • [02-28-10] GLEW 1.5.3 fixes minor bugs and adds three new extensions
      • -
    • [12-31-09] GLEW 1.5.2 adds support for OpenGL 3.1, OpenGL 3.2 and new extensions
      • -
    • [11-03-08] GLEW 1.5.1 adds support for OpenGL 3.0 and 31 new extensions
      • -
    • [12-27-07] GLEW 1.5.0 is released under less restrictive licenses
      • -
    • [04-27-07] GLEW 1.4.0 is released
      • -
    • [03-08-07] GLEW is included in the NVIDIA OpenGL SDK
      • -
    • [03-04-07] GLEW 1.3.6 is released
      • -
    • [02-28-07] Repository is migrated to SVN
      • -
    • [02-25-07] GLEW is included in the OpenGL SDK
      • -
    • [11-21-06] GLEW 1.3.5 adds OpenGL 2.1 and NVIDIA G80 extensions
      • -
    • [03-04-06] GLEW 1.3.4 adds support for five new extensions
      • -
    • [05-16-05] GLEW 1.3.3 is released
      • -
    • [03-16-05] GLEW 1.3.2 adds support for GL_APPLE_pixel_buffer
      • -
    • [02-11-05] gljava and sdljava provide a Java binding to OpenGL via GLEW
      • -
    • [02-02-05] GLEW 1.3.1 adds support for GL_EXT_framebuffer_object
      • -
    • [01-04-05] GLEW 1.3.0 adds core OpenGL 2.0 support plus many enhancements
      • -
    • [12-22-04] GLEWpy Python wrapper announced
      • -
    • [12-12-04] Mailing lists created on sourceforge
      • -
    • [12-06-04] GLEW 1.2.5 adds new extensions and support for FreeBSD
      • +
    • [06-27-2025] GLEW 2.3.0 new extensions and minor bug fixes
      • +
    • [03-15-2020] GLEW 2.2.0 new extensions and minor bug fixes
      • +
    • [07-31-2017] GLEW 2.1.0 adds support for OpenGL 4.6, new extensions and minor bug fixes
      • +
    • [07-24-2016] GLEW 2.0.0 adds support for forward-compatible contexts, adds new extensions, OSMesa and EGL support, MX discontinued and minor bug fixes
      • +
    • [08-10-2015] GLEW 1.13.0 adds support for new extensions, fixes minor bugs
      • +
    • [26-01-2015] GLEW 1.12.0 fixes minor bugs and adds new extensions
      • +
    • [08-11-2014] GLEW 1.11.0 adds support for OpenGL 4.5, new extensions
      • +
    • [07-22-2013] GLEW 1.10.0 adds support for OpenGL 4.4, new extensions
      • +
    • [08-06-2012] GLEW 1.9.0 adds support for OpenGL 4.3, new extensions
      • +
    • [07-17-2012] GLEW 1.8.0 fixes minor bugs and adds new extensions
      • +
    • [08-26-2011] GLEW 1.7.0 adds support for OpenGL 4.2, new extensions, fixes bugs
      • +
    • [04-27-2011] GLEW 1.6.0 fixes minor bugs and adds eight new extensions
      • +
    • [01-31-2011] GLEW 1.5.8 fixes minor bugs and adds two new extensions
      • +
    • [11-03-2010] GLEW 1.5.7 fixes minor bugs and adds one new extension
      • +
    • [09-07-2010] GLEW 1.5.6 adds support for OpenGL 4.1, fixes bugs
      • +
    • [07-13-2010] GLEW 1.5.5 fixes minor bugs and adds new extensions
      • +
    • [04-21-2010] GLEW 1.5.4 adds support for OpenGL 3.3, OpenGL 4.0 and new extensions, fixes bugs
      • +
    • [02-28-2010] GLEW 1.5.3 fixes minor bugs and adds three new extensions
      • +
    • [12-31-2009] GLEW 1.5.2 adds support for OpenGL 3.1, OpenGL 3.2 and new extensions
      • +
    • [11-03-2008] GLEW 1.5.1 adds support for OpenGL 3.0 and 31 new extensions
      • +
    • [12-27-2007] GLEW 1.5.0 is released under less restrictive licenses
      • +
    • [04-27-2007] GLEW 1.4.0 is released
      • +
    • [03-08-2007] GLEW is included in the NVIDIA OpenGL SDK
      • +
    • [03-04-2007] GLEW 1.3.6 is released
      • +
    • [02-28-2007] Repository is migrated to SVN
      • +
    • [02-25-2007] GLEW is included in the OpenGL SDK
      • +
    • [11-21-2006] GLEW 1.3.5 adds OpenGL 2.1 and NVIDIA G80 extensions
      • +
    • [03-04-2006] GLEW 1.3.4 adds support for five new extensions
      • +
    • [05-16-2005] GLEW 1.3.3 is released
      • +
    • [03-16-2005] GLEW 1.3.2 adds support for GL_APPLE_pixel_buffer
      • +
    • [02-11-2005] gljava and sdljava provide a Java binding to OpenGL via GLEW
      • +
    • [02-02-2005] GLEW 1.3.1 adds support for GL_EXT_framebuffer_object
      • +
    • [01-04-2005] GLEW 1.3.0 adds core OpenGL 2.0 support plus many enhancements
      • +
    • [12-22-2004] GLEWpy Python wrapper announced
      • +
    • [12-12-2004] Mailing lists created on sourceforge
      • +
    • [12-06-2004] GLEW 1.2.5 adds new extensions and support for FreeBSD

    Links

    @@ -206,7 +205,6 @@ The latest release contains support for OpenGL 4.6, compatibility and forward-co
  • OpenGL Extension Registry
  • OpenGL Wiki: Extensions
  • NVIDIA OpenGL Extension Specifications
    • -
  • Apple OpenGL Extensions Guide
    • diff --git a/doc/install.html b/doc/install.html index 3c4993e..9b12d4a 100644 --- a/doc/install.html +++ b/doc/install.html @@ -1,7 +1,7 @@ diff --git a/doc/log.html b/doc/log.html index c5f8ab7..86373c7 100644 --- a/doc/log.html +++ b/doc/log.html @@ -1,7 +1,7 @@

    Change Log

    +
    +
      +
    • 2.3.0 [12-27-2025] + +
        +
      • New extensions: +
          +
        • GL_ARM_shader_core_properties +
        • GL_EXT_EGL_image_storage_compression +
        • GL_EXT_framebuffer_blit_layers +
        • GL_EXT_separate_depth_stencil +
        • GL_EXT_shader_clock +
        • GL_EXT_shader_samples_identical +
        • GL_EXT_texture_storage_compression +
        • GL_IMG_pvric_end_to_end_signature +
        • GL_IMG_tile_region_protection +
        • GL_MESA_bgra +
        • GL_MESA_framebuffer_flip_x +
        • GL_MESA_framebuffer_swap_xy +
        • GL_MESA_texture_const_bandwidth +
        • GL_NV_memory_object_sparse +
        • GL_NV_primitive_shading_rate +
        • GL_NV_timeline_semaphore +
        • GL_NV_uniform_buffer_std430_layout +
        • GL_QCOM_frame_extrapolation +
        • GL_QCOM_motion_estimation +
        • GL_QCOM_render_sRGB_R8_RG8 +
        • GL_QCOM_render_shared_exponent +
        • GL_QCOM_shading_rate +
        • GL_QCOM_texture_lod_bias +
        • GL_QCOM_ycbcr_degamma +
        • EGL_ANDROID_telemetry_hint +
        • EGL_ANGLE_sync_control_rate +
        • EGL_EXT_config_select_group +
        • EGL_EXT_device_drm_render_node +
        • EGL_EXT_device_persistent_id +
        • EGL_EXT_device_query_name +
        • EGL_EXT_display_alloc +
        • EGL_EXT_explicit_device +
        • EGL_EXT_gl_colorspace_bt2020_hlg +
        • EGL_EXT_platform_xcb +
        • EGL_EXT_present_opaque +
        • EGL_EXT_query_reset_notification_strategy +
        • EGL_EXT_surface_compression +
        • EGL_NV_stream_consumer_eglimage +
        • EGL_NV_stream_consumer_eglimage_use_scanout_attrib +
        • EGL_QNX_image_native_buffer +
        • EGL_QNX_platform_screen +
        • GLX_EXT_get_drawable_type +
        +
      + +
        +
      • Contributors: +
          +
        • Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, Anuraag Agrawal, Ari Pollak, Bertie Wheen, Bertrand Marc, Christian Rauch, Daniel Bernar, Danilo Spinella, Debian Janitor, Dmitry Kalinkin, Fabrizio Regalli, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Helmut Grohne, ibbem, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, luz paz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, OndÅ™ej Nový, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, SpaceIm, Tim Gates, Vanfanel, Vladimir Vukicevic, Xavier Bonaventura, Yaroslav Halchenko +
        +
      + +
    +
    • 2.2.0 [03-15-20] @@ -279,6 +337,13 @@ THE POSSIBILITY OF SUCH DAMAGE.
    +
      +
    • Contributors: +
        +
      • Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, Anuraag Agrawal, Ari Pollak, Bertie Wheen, Bertrand Marc, Christian Rauch, CiriUp, Daniel Bernar, Danilo Spinella, Debian Janitor, Deve, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Helmut Grohne, ibbem, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, luz paz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, OndÅ™ej Nový, Paul Steinbrecher, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, SpaceIm, Stefan Zabka, Steve Robinson, TheVice, Tim Gates, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, wiranoid, Xavier Bonaventura, Yaroslav Halchenko +
      +
    +
    @@ -296,7 +361,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
    • Bug fixes:
        -
      • Resovled crash when glXGetCurrentDisplay() is NULL +
      • Resolved crash when glXGetCurrentDisplay() is NULL
      • CMake: only install PDB files with MSVC
      • wglGetProcAddress crash with NOGDI defined
      • Mac: using -Os rather than -O2 @@ -342,6 +407,13 @@ THE POSSIBILITY OF SUCH DAMAGE.
    +
      +
    • Contributors: +
        +
      • Abdo Roig-Maranges, Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, anatoly techtonik, Anuraag Agrawal, Ari Pollak, Bertie Wheen, Bertrand Marc, Christian Rauch, CiriUp, Claudio, Daniel Bernar, Danilo Margarido, Danilo Spinella, Debian Janitor, Deve, Dillon Cower, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Helmut Grohne, ibbem, jasjuang, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, luz paz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Miguel Vera, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, OndÅ™ej Nový, Paul Steinbrecher, Rashad Kanavath, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, Shanee, SpaceIm, Stefan Zabka, Steve Robinson, Tan Li Boon, TheVice, Tim Gates, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, wiranoid, Xavier Bonaventura, Yaroslav Halchenko +
      +
    +
    @@ -381,12 +453,21 @@ THE POSSIBILITY OF SUCH DAMAGE.
  • GLX_EXT_libglvnd
  • GLX_NV_robustness_video_memory_purge + + +
      +
    • Contributors: +
        +
      • Abdo Roig-Maranges, Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, anatoly techtonik, Anuraag Agrawal, Ari Pollak, Bertie Wheen, Bertrand Marc, Christian Rauch, CiriUp, Claudio, Daniel Bernar, Danilo Margarido, Danilo Spinella, Debian Janitor, Deve, Dillon Cower, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Gyusun Yeom, Helmut Grohne, ibbem, Icy Defiance, jasjuang, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, Loufis, luz paz, Marcel Metz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Miguel Vera, Mischa Spiegelmock, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, OndÅ™ej Nový, Paul Steinbrecher, Rashad Kanavath, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, Shanee, SpaceIm, Stefan Zabka, Steve Robinson, stopiccot, Tamas Kenez, Tan Li Boon, TheVice, Tim Gates, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, Wes Tarro, wiranoid, Xavier Bonaventura, Yaroslav Halchenko +
      +
    +
      -
    • 1.13.0 [08-10-15] +
    • 1.13.0 [08-10-2015]
      • Enhancements:
          @@ -417,13 +498,25 @@ THE POSSIBILITY OF SUCH DAMAGE.
        • GL_OVR_multiview
        • GL_OVR_multiview2
        +
      + + + +
        +
      • Contributors: +
          +
        • Abdo Roig-Maranges, Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, anatoly techtonik, Anuraag Agrawal, Ari Pollak, BastiaanOlij, Bertie Wheen, Bertrand Marc, Christian Rauch, CiriUp, Claudio, Daniel Bernar, Danilo Margarido, Danilo Spinella, Debian Janitor, Deve, Dillon Cower, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Gyusun Yeom, Helmut Grohne, ibbem, Icy Defiance, jasjuang, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, Lauri Nurmi, Loufis, luz paz, Marcel Metz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Miguel Vera, Mischa Spiegelmock, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, OndÅ™ej Nový, Paul Steinbrecher, Rashad Kanavath, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, Shanee, SpaceIm, Stefan Zabka, Steve Robinson, stopiccot, Tamas Kenez, Tan Li Boon, TheVice, Tim Gates, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, Wes Tarro, wiranoid, xantares, Xavier Bonaventura, Yaroslav Halchenko, yy-yyaa +
        +
      +
      -
    • 1.12.0 [01-26-15] +
    • 1.12.0 [01-26-2015]
      • New extensions:
          @@ -445,13 +538,25 @@ THE POSSIBILITY OF SUCH DAMAGE.
        • GL_NV_uniform_buffer_unified_memory
        • GL_NV_viewport_array2
        +
      + + + +
        +
      • Contributors: +
          +
        • Abdo Roig-Maranges, Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, anatoly techtonik, Anuraag Agrawal, Ari Pollak, BastiaanOlij, Bertie Wheen, Bertrand Marc, BryceMehring, Carsten Neumann, Christian Rauch, CiriUp, Claudio, Daniel Bernar, Danilo Margarido, Danilo Spinella, Debian Janitor, Deve, Dillon Cower, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Frank Park, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Gyusun Yeom, Helmut Grohne, ibbem, Icy Defiance, jasjuang, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Kekschen, Kerby Geffrard, Lauri Nurmi, Loufis, luz paz, Marcel Metz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Matthias Goldhoorn, Miguel Vera, Mischa Spiegelmock, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, omniavinco, OndÅ™ej Nový, Paul Steinbrecher, Rashad Kanavath, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, Shanee, SpaceIm, Stefan Zabka, Steve Robinson, stopiccot, Tamas Kenez, Tan Li Boon, TheVice, Tim Gates, Togo Nishigaki, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, Wes Tarro, wiranoid, xantares, Xavier Bonaventura, Yaroslav Halchenko, yy-yyaa +
        +
      +
      -
    • 1.11.0 [08-11-14] +
    • 1.11.0 [08-11-2014]
      • New features:
          @@ -501,13 +606,25 @@ THE POSSIBILITY OF SUCH DAMAGE.
        • WGL_ARB_context_flush_control
        • WGL_NV_delay_before_swap
        -
      • Bug fixes +
      + + + +
        +
      • Contributors: +
          +
        • Abdo Roig-Maranges, Alastair McKinstry, Alessio Treglia, Alexey Tereshenkov, Amaya Rodrigo Sastre, anatoly techtonik, Anuraag Agrawal, Ari Pollak, BastiaanOlij, Bertie Wheen, Bertrand Marc, BryceMehring, Carsten Neumann, Christian Rauch, CiriUp, Claudio, Daniel Bernar, Danilo Margarido, Danilo Spinella, DÄvis, Debian Janitor, Deve, Dillon Cower, dimitri, Dmitry Kalinkin, Eonfge, Fabrizio Regalli, Frank Park, Gianfranco Costamagna, G'lek Tarssza, grahamreeds, Gyusun Yeom, hasufell, Helmut Grohne, ibbem, Icy Defiance, jasjuang, Jean-Christophe Fillion-Robin, Jelmer Vernooij, Joost Yervante Damad, Jose Santiago, Julian Squires, Julien Schueller, Keith Rosenberg, Kekschen, Kerby Geffrard, Lauri Nurmi, Loufis, luz paz, Marcel Metz, Marcelo E. Magallon, Marvin Schmidt, Matteo F. Vescovi, Matthias Bentrup, Matthias Goldhoorn, Miguel Vera, Mischa Spiegelmock, Ned Loynd, Nicolas Caramelli, Nigel Stewart, NoamDev, Olli Kallioinen, omniavinco, OndÅ™ej Nový, Paul Steinbrecher, Rashad Kanavath, rconde, Rene, ReneÌ Schwaiger, Ross Burton, Ryan Schmidt, Shanee, SpaceIm, Stefan Zabka, Steve Robinson, stopiccot, Tamas Kenez, Tan Li Boon, TheVice, Tim Gates, Togo Nishigaki, Valentin Sarthou, Vanfanel, Vladimir Vukicevic, Wes Tarro, wiranoid, xantares, Xavier Bonaventura, Yaroslav Halchenko, yy-yyaa +
        +
      +
      -
    • 1.10.0 [07-22-13] +
    • 1.10.0 [07-22-2013]
      • New features:
          @@ -567,7 +684,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
            -
          • 1.9.0 [08-06-12] +
          • 1.9.0 [08-06-2012]
            • New features:
                @@ -617,7 +734,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                  -
                • 1.8.0 [07-17-12] +
                • 1.8.0 [07-17-2012]
                  • New extensions:
                      @@ -652,7 +769,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                        -
                      • 1.7.0 [08-26-11] +
                      • 1.7.0 [08-26-2011]
                        • New features:
                            @@ -694,7 +811,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                              -
                            • 1.6.0 [04-27-11] +
                            • 1.6.0 [04-27-2011]
                              • New extensions:
                                  @@ -724,7 +841,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                    -
                                  • 1.5.8 [01-31-11] +
                                  • 1.5.8 [01-31-2011]
                                    • New extensions:
                                        @@ -745,7 +862,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                          -
                                        • 1.5.7 [11-03-10] +
                                        • 1.5.7 [11-03-2010]
                                          • New extension:
                                              @@ -763,7 +880,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                -
                                              • 1.5.6 [09-07-10] +
                                              • 1.5.6 [09-07-2010]
                                                • New features:
                                                    @@ -791,7 +908,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                      -
                                                    • 1.5.5 [07-13-10] +
                                                    • 1.5.5 [07-13-2010]
                                                      • New extensions:
                                                          @@ -817,7 +934,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                            -
                                                          • 1.5.4 [04-21-10] +
                                                          • 1.5.4 [04-21-2010]
                                                            • New features:
                                                                @@ -864,7 +981,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                  -
                                                                • 1.5.3 [02-28-10] +
                                                                • 1.5.3 [02-28-2010]
                                                                  • New extensions:
                                                                      @@ -883,7 +1000,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                        -
                                                                      • 1.5.2 [12-31-09] +
                                                                      • 1.5.2 [12-31-2009]
                                                                        • New features:
                                                                            @@ -954,7 +1071,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                              -
                                                                            • 1.5.1 [11-03-08] +
                                                                            • 1.5.1 [11-03-2008]
                                                                              • New features:
                                                                                  @@ -1009,7 +1126,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                                    -
                                                                                  • 1.5.0 [12-27-07] +
                                                                                  • 1.5.0 [12-27-2007]
                                                                                    • New features:
                                                                                        @@ -1025,7 +1142,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                                    • Bug fixes:
                                                                                        -
                                                                                      • Incorrent 64-bit type definitions +
                                                                                      • Incorrect 64-bit type definitions
                                                                                      • Do not strip static library on install
                                                                                      • Missing tokens in GL_ATI_fragment_shader and WGL_{ARB,EXT}_make_current_read
                                                                                      • Missing tokens in GL_VERSION_2_1 @@ -1036,7 +1153,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
                                                                                        -
                                                                                      • 1.4.0 [04-27-07] +
                                                                                      • 1.4.0 [04-27-2007]
                                                                                        • New features:
                                                                                            @@ -1058,7 +1175,7 @@ corruption of their values
                                                                                            -
                                                                                          • 1.3.6 [03-04-07] +
                                                                                          • 1.3.6 [03-04-2007]
                                                                                            • New extensions:
                                                                                                @@ -1073,14 +1190,14 @@ corruption of their values
                                                                                              • Missing include guards in glxew.h
                                                                                              • Makefile and install problems for Cygwin builds
                                                                                              • Install problem for Linux AMD64 builds -
                                                                                              • Incorrent token in GL_ATI_texture_compression_3dc +
                                                                                              • Incorrect token in GL_ATI_texture_compression_3dc
                                                                                              • Missing tokens from GL_ATIX_point_sprites
                                                                                            -
                                                                                          • 1.3.5 [11-21-06] +
                                                                                          • 1.3.5 [11-21-2006]
                                                                                            • New features:
                                                                                                @@ -1129,7 +1246,7 @@ corruption of their values
                                                                                                -
                                                                                              • 1.3.4 [03-04-06] +
                                                                                              • 1.3.4 [03-04-2006]
                                                                                                • New extensions:
                                                                                                    @@ -1152,7 +1269,7 @@ corruption of their values
                                                                                                    -
                                                                                                  • 1.3.3 [05-16-05] +
                                                                                                  • 1.3.3 [05-16-2005]
                                                                                                    • New feature:
                                                                                                        @@ -1171,7 +1288,7 @@ corruption of their values
                                                                                                        -
                                                                                                      • 1.3.2 [03-16-05] +
                                                                                                      • 1.3.2 [03-16-2005]
                                                                                                        • New extension:
                                                                                                            @@ -1189,7 +1306,7 @@ corruption of their values
                                                                                                            -
                                                                                                          • 1.3.1 [02-02-05] +
                                                                                                          • 1.3.1 [02-02-2005]
                                                                                                            • New features:
                                                                                                                @@ -1210,7 +1327,7 @@ corruption of their values
                                                                                                                -
                                                                                                              • 1.3.0 [01-04-05] +
                                                                                                              • 1.3.0 [01-04-2005]
                                                                                                                • New features:
                                                                                                                    @@ -1231,7 +1348,7 @@ corruption of their values
                                                                                                                    -
                                                                                                                  • 1.2.5 [12-06-04] +
                                                                                                                  • 1.2.5 [12-06-2004]
                                                                                                                    • New extensions:
                                                                                                                        @@ -1252,7 +1369,7 @@ corruption of their values
                                                                                                                        -
                                                                                                                      • 1.2.4 [09-06-04] +
                                                                                                                      • 1.2.4 [09-06-2004]
                                                                                                                        • Added ARB_draw_buffers and ARB_texture_rectangle
                                                                                                                        • Fixed bug in ARB_shader_objects @@ -1261,7 +1378,7 @@ corruption of their values
                                                                                                                          -
                                                                                                                        • 1.2.3 [06-10-04] +
                                                                                                                        • 1.2.3 [06-10-2004]
                                                                                                                          • Added GL_NV_fragment_program2, GL_NV_fragment_program_option, GL_NV_vertex_program2_option, GL_NV_vertex_program3
                                                                                                                          • Bug fix in GL_ARB_vertex_blend @@ -1269,7 +1386,7 @@ corruption of their values
                                                                                                                            -
                                                                                                                          • 1.2.2 [05-08-04] +
                                                                                                                          • 1.2.2 [05-08-2004]
                                                                                                                            • Added GL_EXT_pixel_buffer_object, removed GL_NV_element_array
                                                                                                                            • Fixed GLEW_MX problems @@ -1278,7 +1395,7 @@ corruption of their values
                                                                                                                              -
                                                                                                                            • 1.2.1 [03-18-04] +
                                                                                                                            • 1.2.1 [03-18-2004]
                                                                                                                              • Bug fix in OpenGL version query (early release of 1.2.0 contained this bug)
                                                                                                                              • Bug fix in GL_ARB_shader_objects and temporary bug fix in GL_ARB_vertex_shader @@ -1287,7 +1404,7 @@ corruption of their values
                                                                                                                                -
                                                                                                                              • 1.2.0 [02-19-04] +
                                                                                                                              • 1.2.0 [02-19-2004]
                                                                                                                                • Added full OpenGL 1.5 support
                                                                                                                                • Added support for multiple rendering contexts with different capabilities @@ -1299,7 +1416,7 @@ corruption of their values
                                                                                                                                  -
                                                                                                                                • 1.1.4 [12-15-03] +
                                                                                                                                • 1.1.4 [12-15-2003]
                                                                                                                                  • Added GL_APPLE_float_pixels, GL_APPLE_texture_range, GL_EXT_texture_cube_map, GL_EXT_texture_edge_clamp, @@ -1309,7 +1426,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                    -
                                                                                                                                  • 1.1.3 [10-28-03] +
                                                                                                                                  • 1.1.3 [10-28-2003]
                                                                                                                                    • Added Solaris and Darwin support
                                                                                                                                    • Added GL_ARB_fragment_shader, GL_ARB_shader_objects, and GL_ARB_vertex_shader @@ -1319,7 +1436,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                      -
                                                                                                                                    • 1.1.2 [09-15-03] +
                                                                                                                                    • 1.1.2 [09-15-2003]
                                                                                                                                      • Removed dependency on WGL_{ARB,EXT}_extensions_string to make GLEW run on Matrox cards
                                                                                                                                      • Added glewGetString for querying the GLEW version string @@ -1327,7 +1444,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                        -
                                                                                                                                      • 1.1.1 [08-11-03] +
                                                                                                                                      • 1.1.1 [08-11-2003]
                                                                                                                                        • Added GLX_NV_float_buffer, GL_ARB_shading_language_100, and GL_ARB_texture_non_power_of_two
                                                                                                                                        • Fixed bug in GL_ARB_vertex_buffer_object @@ -1336,7 +1453,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                          -
                                                                                                                                        • 1.1.0 [07-08-03] +
                                                                                                                                        • 1.1.0 [07-08-2003]
                                                                                                                                          • Added automatic code generation
                                                                                                                                          • Added almost every extension in the registry @@ -1347,7 +1464,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                            -
                                                                                                                                          • 1.0.7 [06-29-03] +
                                                                                                                                          • 1.0.7 [06-29-2003]
                                                                                                                                            • Added GL_EXT_depth_bounds_test
                                                                                                                                            • Fixed typos @@ -1355,7 +1472,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                              -
                                                                                                                                            • 1.0.6 [05-05-03] +
                                                                                                                                            • 1.0.6 [05-05-2003]
                                                                                                                                              • Added ARB_vertex_buffer_object and NV_half_float
                                                                                                                                              • Updated wglinfo @@ -1364,7 +1481,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                -
                                                                                                                                              • 1.0.5 [02-17-03] +
                                                                                                                                              • 1.0.5 [02-17-2003]
                                                                                                                                                • Bug fixes
                                                                                                                                                • Added wglinfo @@ -1373,7 +1490,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                  -
                                                                                                                                                • 1.0.4 [02-02-03] +
                                                                                                                                                • 1.0.4 [02-02-2003]
                                                                                                                                                  • Added NV_texture_expand_normal
                                                                                                                                                  • Added mingw support @@ -1382,7 +1499,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                    -
                                                                                                                                                  • 1.0.3 [01-09-03] +
                                                                                                                                                  • 1.0.3 [01-09-2003]
                                                                                                                                                    • Cleaned up ATI extensions
                                                                                                                                                    • Changed function prototypes to match glext.h @@ -1392,7 +1509,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                      -
                                                                                                                                                    • 1.0.2 [12-21-02] +
                                                                                                                                                    • 1.0.2 [12-21-2002]
                                                                                                                                                      • Added list of supported extensions to documentation
                                                                                                                                                      • Added NV_half_float and NV_texgen_emboss @@ -1400,7 +1517,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                        -
                                                                                                                                                      • 1.0.1 [12-17-02] +
                                                                                                                                                      • 1.0.1 [12-17-2002]
                                                                                                                                                        • Bug fixes
                                                                                                                                                        • Added glewGetExtension @@ -1408,7 +1525,7 @@ GLX_ATI_pixel_format_float, and GLX_ATI_render_texture
                                                                                                                                                          -
                                                                                                                                                        • 1.0.0 [12-12-02] +
                                                                                                                                                        • 1.0.0 [12-12-2002]
                                                                                                                                                          • Initial release
                                                                                                                                                          diff --git a/doc/wglew.html b/doc/wglew.html index 7b4db0a..8958ec9 100644 --- a/doc/wglew.html +++ b/doc/wglew.html @@ -1,7 +1,7 @@ diff --git a/include/GL/eglew.h b/include/GL/eglew.h index e9e5a0b..71091dd 100644 --- a/include/GL/eglew.h +++ b/include/GL/eglew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -157,17 +157,10 @@ typedef khronos_stime_nanoseconds_t EGLnsecsANDROID; struct EGLClientPixmapHI; struct AHardwareBuffer; -#define EGL_DONT_CARE ((EGLint)-1) - -#define EGL_NO_CONTEXT ((EGLContext)0) -#define EGL_NO_DISPLAY ((EGLDisplay)0) -#define EGL_NO_IMAGE ((EGLImage)0) -#define EGL_NO_SURFACE ((EGLSurface)0) -#define EGL_NO_SYNC ((EGLSync)0) - -#define EGL_UNKNOWN ((EGLint)-1) - -#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0) +/* Wayland types for WL_bind_wayland_display purposes */ +struct wl_buffer; +struct wl_display; +struct wl_resource; EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (const char *procname); /* ---------------------------- EGL_VERSION_1_0 ---------------------------- */ @@ -175,6 +168,10 @@ EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (c #ifndef EGL_VERSION_1_0 #define EGL_VERSION_1_0 1 +#define EGL_DONT_CARE EGL_CAST(EGLint,-1) +#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0) +#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0) +#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0) #define EGL_FALSE 0 #define EGL_PBUFFER_BIT 0x0001 #define EGL_TRUE 1 @@ -322,6 +319,7 @@ typedef EGLBoolean ( * PFNEGLSWAPINTERVALPROC) (EGLDisplay dpy, EGLint interv #ifndef EGL_VERSION_1_2 #define EGL_VERSION_1_2 1 +#define EGL_UNKNOWN EGL_CAST(EGLint,-1) #define EGL_OPENGL_ES_BIT 0x0001 #define EGL_OPENVG_BIT 0x0002 #define EGL_LUMINANCE_SIZE 0x303D @@ -332,6 +330,7 @@ typedef EGLBoolean ( * PFNEGLSWAPINTERVALPROC) (EGLDisplay dpy, EGLint interv #define EGL_RENDER_BUFFER 0x3086 #define EGL_COLORSPACE 0x3087 #define EGL_ALPHA_FORMAT 0x3088 +#define EGL_COLORSPACE_sRGB 0x3089 #define EGL_COLORSPACE_LINEAR 0x308A #define EGL_ALPHA_FORMAT_NONPRE 0x308B #define EGL_ALPHA_FORMAT_PRE 0x308C @@ -378,6 +377,7 @@ typedef EGLBoolean ( * PFNEGLWAITCLIENTPROC) ( void ); #define EGL_CONFORMANT 0x3042 #define EGL_VG_COLORSPACE 0x3087 #define EGL_VG_ALPHA_FORMAT 0x3088 +#define EGL_VG_COLORSPACE_sRGB 0x3089 #define EGL_VG_COLORSPACE_LINEAR 0x308A #define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B #define EGL_VG_ALPHA_FORMAT_PRE 0x308C @@ -392,6 +392,7 @@ typedef EGLBoolean ( * PFNEGLWAITCLIENTPROC) ( void ); #ifndef EGL_VERSION_1_4 #define EGL_VERSION_1_4 1 +#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0) #define EGL_OPENGL_BIT 0x0008 #define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200 #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400 @@ -413,6 +414,8 @@ typedef EGLContext ( * PFNEGLGETCURRENTCONTEXTPROC) ( void ); #ifndef EGL_VERSION_1_5 #define EGL_VERSION_1_5 1 +#define EGL_NO_IMAGE EGL_CAST(EGLImage,0) +#define EGL_NO_SYNC EGL_CAST(EGLSync,0) #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001 #define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001 #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002 @@ -548,6 +551,8 @@ typedef EGLClientBuffer ( * PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC) (const EG #ifndef EGL_ANDROID_get_frame_timestamps #define EGL_ANDROID_get_frame_timestamps 1 +#define EGL_TIMESTAMP_INVALID_ANDROID EGL_CAST(EGLnsecsANDROID,-1) +#define EGL_TIMESTAMP_PENDING_ANDROID EGL_CAST(EGLnsecsANDROID,-2) #define EGL_TIMESTAMPS_ANDROID 0x3430 #define EGL_COMPOSITE_DEADLINE_ANDROID 0x3431 #define EGL_COMPOSITE_INTERVAL_ANDROID 0x3432 @@ -607,6 +612,7 @@ typedef EGLClientBuffer ( * PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) (const struc #ifndef EGL_ANDROID_native_fence_sync #define EGL_ANDROID_native_fence_sync 1 +#define EGL_NO_NATIVE_FENCE_FD_ANDROID -1 #define EGL_SYNC_NATIVE_FENCE_ANDROID 0x3144 #define EGL_SYNC_NATIVE_FENCE_FD_ANDROID 0x3145 #define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID 0x3146 @@ -643,6 +649,17 @@ typedef EGLBoolean ( * PFNEGLPRESENTATIONTIMEANDROIDPROC) (EGLDisplay dpy, EGLSu #endif /* EGL_ANDROID_recordable */ +/* ----------------------- EGL_ANDROID_telemetry_hint ---------------------- */ + +#ifndef EGL_ANDROID_telemetry_hint +#define EGL_ANDROID_telemetry_hint 1 + +#define EGL_TELEMETRY_HINT_ANDROID 0x3570 + +#define EGLEW_ANDROID_telemetry_hint EGLEW_GET_VAR(__EGLEW_ANDROID_telemetry_hint) + +#endif /* EGL_ANDROID_telemetry_hint */ + /* ---------------- EGL_ANGLE_d3d_share_handle_client_buffer --------------- */ #ifndef EGL_ANGLE_d3d_share_handle_client_buffer @@ -690,6 +707,19 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLS #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */ +/* ---------------------- EGL_ANGLE_sync_control_rate ---------------------- */ + +#ifndef EGL_ANGLE_sync_control_rate +#define EGL_ANGLE_sync_control_rate 1 + +typedef EGLBoolean ( * PFNEGLGETMSCRATEANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint* numerator, EGLint* denominator); + +#define eglGetMscRateANGLE EGLEW_GET_FUN(__eglewGetMscRateANGLE) + +#define EGLEW_ANGLE_sync_control_rate EGLEW_GET_VAR(__EGLEW_ANGLE_sync_control_rate) + +#endif /* EGL_ANGLE_sync_control_rate */ + /* ---------------------- EGL_ANGLE_window_fixed_size ---------------------- */ #ifndef EGL_ANGLE_window_fixed_size @@ -812,6 +842,17 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i #endif /* EGL_EXT_compositor */ +/* ---------------------- EGL_EXT_config_select_group ---------------------- */ + +#ifndef EGL_EXT_config_select_group +#define EGL_EXT_config_select_group 1 + +#define EGL_CONFIG_SELECT_GROUP_EXT 0x34C0 + +#define EGLEW_EXT_config_select_group EGLEW_GET_VAR(__EGLEW_EXT_config_select_group) + +#endif /* EGL_EXT_config_select_group */ + /* ------------------- EGL_EXT_create_context_robustness ------------------- */ #ifndef EGL_EXT_create_context_robustness @@ -831,6 +872,7 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i #ifndef EGL_EXT_device_base #define EGL_EXT_device_base 1 +#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0) #define EGL_BAD_DEVICE_EXT 0x322B #define EGL_DEVICE_EXT 0x322C @@ -850,6 +892,17 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i #endif /* EGL_EXT_device_drm */ +/* --------------------- EGL_EXT_device_drm_render_node -------------------- */ + +#ifndef EGL_EXT_device_drm_render_node +#define EGL_EXT_device_drm_render_node 1 + +#define EGL_DRM_RENDER_NODE_FILE_EXT 0x3377 + +#define EGLEW_EXT_device_drm_render_node EGLEW_GET_VAR(__EGLEW_EXT_device_drm_render_node) + +#endif /* EGL_EXT_device_drm_render_node */ + /* ----------------------- EGL_EXT_device_enumeration ---------------------- */ #ifndef EGL_EXT_device_enumeration @@ -869,16 +922,35 @@ typedef EGLBoolean ( * PFNEGLQUERYDEVICESEXTPROC) (EGLint max_devices, EGLDevice #define EGL_EXT_device_openwf 1 #define EGL_OPENWF_DEVICE_ID_EXT 0x3237 +#define EGL_OPENWF_DEVICE_EXT 0x333D #define EGLEW_EXT_device_openwf EGLEW_GET_VAR(__EGLEW_EXT_device_openwf) #endif /* EGL_EXT_device_openwf */ +/* ---------------------- EGL_EXT_device_persistent_id --------------------- */ + +#ifndef EGL_EXT_device_persistent_id +#define EGL_EXT_device_persistent_id 1 + +#define EGL_DEVICE_UUID_EXT 0x335C +#define EGL_DRIVER_UUID_EXT 0x335D +#define EGL_DRIVER_NAME_EXT 0x335E + +typedef EGLBoolean ( * PFNEGLQUERYDEVICEBINARYEXTPROC) (EGLDeviceEXT device, EGLint name, EGLint max_size, void* value, EGLint* size); + +#define eglQueryDeviceBinaryEXT EGLEW_GET_FUN(__eglewQueryDeviceBinaryEXT) + +#define EGLEW_EXT_device_persistent_id EGLEW_GET_VAR(__EGLEW_EXT_device_persistent_id) + +#endif /* EGL_EXT_device_persistent_id */ + /* -------------------------- EGL_EXT_device_query ------------------------- */ #ifndef EGL_EXT_device_query #define EGL_EXT_device_query 1 +#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0) #define EGL_BAD_DEVICE_EXT 0x322B #define EGL_DEVICE_EXT 0x322C @@ -894,6 +966,54 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLint #endif /* EGL_EXT_device_query */ +/* ----------------------- EGL_EXT_device_query_name ----------------------- */ + +#ifndef EGL_EXT_device_query_name +#define EGL_EXT_device_query_name 1 + +#define EGL_RENDERER_EXT 0x335F + +#define EGLEW_EXT_device_query_name EGLEW_GET_VAR(__EGLEW_EXT_device_query_name) + +#endif /* EGL_EXT_device_query_name */ + +/* ------------------------- EGL_EXT_display_alloc ------------------------- */ + +#ifndef EGL_EXT_display_alloc +#define EGL_EXT_display_alloc 1 + +#define EGL_ALLOC_NEW_DISPLAY_EXT 0x3379 + +typedef EGLBoolean ( * PFNEGLDESTROYDISPLAYEXTPROC) (EGLDisplay dpy); + +#define eglDestroyDisplayEXT EGLEW_GET_FUN(__eglewDestroyDisplayEXT) + +#define EGLEW_EXT_display_alloc EGLEW_GET_VAR(__EGLEW_EXT_display_alloc) + +#endif /* EGL_EXT_display_alloc */ + +/* ------------------------ EGL_EXT_explicit_device ------------------------ */ + +#ifndef EGL_EXT_explicit_device +#define EGL_EXT_explicit_device 1 + +#define EGL_DEVICE_EXT 0x322C + +#define EGLEW_EXT_explicit_device EGLEW_GET_VAR(__EGLEW_EXT_explicit_device) + +#endif /* EGL_EXT_explicit_device */ + +/* -------------------- EGL_EXT_gl_colorspace_bt2020_hlg ------------------- */ + +#ifndef EGL_EXT_gl_colorspace_bt2020_hlg +#define EGL_EXT_gl_colorspace_bt2020_hlg 1 + +#define EGL_GL_COLORSPACE_BT2020_HLG_EXT 0x3540 + +#define EGLEW_EXT_gl_colorspace_bt2020_hlg EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_bt2020_hlg) + +#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */ + /* ------------------ EGL_EXT_gl_colorspace_bt2020_linear ------------------ */ #ifndef EGL_EXT_gl_colorspace_bt2020_linear @@ -1071,6 +1191,8 @@ typedef EGLBoolean ( * PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGLin #ifndef EGL_EXT_output_base #define EGL_EXT_output_base 1 +#define EGL_NO_OUTPUT_LAYER_EXT EGL_CAST(EGLOutputLayerEXT,0) +#define EGL_NO_OUTPUT_PORT_EXT EGL_CAST(EGLOutputPortEXT,0) #define EGL_BAD_OUTPUT_LAYER_EXT 0x322D #define EGL_BAD_OUTPUT_PORT_EXT 0x322E #define EGL_SWAP_INTERVAL_EXT 0x322F @@ -1186,6 +1308,29 @@ typedef EGLDisplay ( * PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void* #endif /* EGL_EXT_platform_x11 */ +/* -------------------------- EGL_EXT_platform_xcb ------------------------- */ + +#ifndef EGL_EXT_platform_xcb +#define EGL_EXT_platform_xcb 1 + +#define EGL_PLATFORM_XCB_EXT 0x31DC +#define EGL_PLATFORM_XCB_SCREEN_EXT 0x31DE + +#define EGLEW_EXT_platform_xcb EGLEW_GET_VAR(__EGLEW_EXT_platform_xcb) + +#endif /* EGL_EXT_platform_xcb */ + +/* ------------------------- EGL_EXT_present_opaque ------------------------ */ + +#ifndef EGL_EXT_present_opaque +#define EGL_EXT_present_opaque 1 + +#define EGL_PRESENT_OPAQUE_EXT 0x31DF + +#define EGLEW_EXT_present_opaque EGLEW_GET_VAR(__EGLEW_EXT_present_opaque) + +#endif /* EGL_EXT_present_opaque */ + /* ----------------------- EGL_EXT_protected_content ----------------------- */ #ifndef EGL_EXT_protected_content @@ -1208,6 +1353,15 @@ typedef EGLDisplay ( * PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void* #endif /* EGL_EXT_protected_surface */ +/* --------------- EGL_EXT_query_reset_notification_strategy --------------- */ + +#ifndef EGL_EXT_query_reset_notification_strategy +#define EGL_EXT_query_reset_notification_strategy 1 + +#define EGLEW_EXT_query_reset_notification_strategy EGLEW_GET_VAR(__EGLEW_EXT_query_reset_notification_strategy) + +#endif /* EGL_EXT_query_reset_notification_strategy */ + /* ------------------- EGL_EXT_stream_consumer_egloutput ------------------- */ #ifndef EGL_EXT_stream_consumer_egloutput @@ -1254,6 +1408,37 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGLSt #endif /* EGL_EXT_surface_SMPTE2086_metadata */ +/* ---------------------- EGL_EXT_surface_compression ---------------------- */ + +#ifndef EGL_EXT_surface_compression +#define EGL_EXT_surface_compression 1 + +#define EGL_SURFACE_COMPRESSION_PLANE1_EXT 0x328E +#define EGL_SURFACE_COMPRESSION_PLANE2_EXT 0x328F +#define EGL_SURFACE_COMPRESSION_EXT 0x34B0 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x34B1 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x34B2 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT 0x34B4 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT 0x34B5 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT 0x34B6 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT 0x34B7 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT 0x34B8 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT 0x34B9 +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT 0x34BA +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT 0x34BB +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT 0x34BC +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT 0x34BD +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT 0x34BE +#define EGL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT 0x34BF + +typedef EGLBoolean ( * PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC) (EGLDisplay dpy, EGLConfig config, const EGLAttrib* attrib_list, EGLint* rates, EGLint rate_size, EGLint* num_rates); + +#define eglQuerySupportedCompressionRatesEXT EGLEW_GET_FUN(__eglewQuerySupportedCompressionRatesEXT) + +#define EGLEW_EXT_surface_compression EGLEW_GET_VAR(__EGLEW_EXT_surface_compression) + +#endif /* EGL_EXT_surface_compression */ + /* -------------------- EGL_EXT_swap_buffers_with_damage ------------------- */ #ifndef EGL_EXT_swap_buffers_with_damage @@ -1606,6 +1791,7 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBKHRPROC) (EGLDisplay dpy, EGLint #ifndef EGL_KHR_image #define EGL_KHR_image 1 +#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0) #define EGL_NATIVE_PIXMAP_KHR 0x30B0 typedef EGLImageKHR ( * PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list); @@ -1623,6 +1809,7 @@ typedef EGLBoolean ( * PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR i #ifndef EGL_KHR_image_base #define EGL_KHR_image_base 1 +#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0) #define EGL_IMAGE_PRESERVED_KHR 0x30D2 #define EGLEW_KHR_image_base EGLEW_GET_VAR(__EGLEW_KHR_image_base) @@ -1740,6 +1927,8 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACE64KHRPROC) (EGLDisplay dpy, EGLSurfac #ifndef EGL_KHR_no_config_context #define EGL_KHR_no_config_context 1 +#define EGL_NO_CONFIG_KHR EGL_CAST(EGLConfig,0) + #define EGLEW_KHR_no_config_context EGLEW_GET_VAR(__EGLEW_KHR_no_config_context) #endif /* EGL_KHR_no_config_context */ @@ -1809,6 +1998,7 @@ typedef EGLBoolean ( * PFNEGLSETDAMAGEREGIONKHRPROC) (EGLDisplay dpy, EGLSurface #ifndef EGL_KHR_reusable_sync #define EGL_KHR_reusable_sync 1 +#define EGL_NO_SYNC_KHR EGL_CAST(EGLSyncKHR,0) #define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001 #define EGL_SYNC_STATUS_KHR 0x30F1 #define EGL_SIGNALED_KHR 0x30F2 @@ -1840,6 +2030,7 @@ typedef EGLBoolean ( * PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync #ifndef EGL_KHR_stream #define EGL_KHR_stream 1 +#define EGL_NO_STREAM_KHR EGL_CAST(EGLStreamKHR,0) #define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210 #define EGL_PRODUCER_FRAME_KHR 0x3212 #define EGL_CONSUMER_FRAME_KHR 0x3213 @@ -1919,6 +2110,8 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERRELEASEKHRPROC) (EGLDisplay dpy, EGLS #ifndef EGL_KHR_stream_cross_process_fd #define EGL_KHR_stream_cross_process_fd 1 +#define EGL_NO_FILE_DESCRIPTOR_KHR EGL_CAST(EGLNativeFileDescriptorKHR,-1) + typedef EGLStreamKHR ( * PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor); typedef EGLNativeFileDescriptorKHR ( * PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream); @@ -2277,6 +2470,41 @@ typedef EGLBoolean ( * PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface su #endif /* EGL_NV_robustness_video_memory_purge */ +/* -------------------- EGL_NV_stream_consumer_eglimage -------------------- */ + +#ifndef EGL_NV_stream_consumer_eglimage +#define EGL_NV_stream_consumer_eglimage 1 + +#define EGL_STREAM_CONSUMER_IMAGE_NV 0x3373 +#define EGL_STREAM_IMAGE_ADD_NV 0x3374 +#define EGL_STREAM_IMAGE_REMOVE_NV 0x3375 +#define EGL_STREAM_IMAGE_AVAILABLE_NV 0x3376 + +typedef EGLint ( * PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum* event, EGLAttrib* aux); +typedef EGLBoolean ( * PFNEGLSTREAMACQUIREIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage* pImage, EGLSync sync); +typedef EGLBoolean ( * PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, const EGLuint64KHR* modifiers, const EGLAttrib* attrib_list); +typedef EGLBoolean ( * PFNEGLSTREAMRELEASEIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync); + +#define eglQueryStreamConsumerEventNV EGLEW_GET_FUN(__eglewQueryStreamConsumerEventNV) +#define eglStreamAcquireImageNV EGLEW_GET_FUN(__eglewStreamAcquireImageNV) +#define eglStreamImageConsumerConnectNV EGLEW_GET_FUN(__eglewStreamImageConsumerConnectNV) +#define eglStreamReleaseImageNV EGLEW_GET_FUN(__eglewStreamReleaseImageNV) + +#define EGLEW_NV_stream_consumer_eglimage EGLEW_GET_VAR(__EGLEW_NV_stream_consumer_eglimage) + +#endif /* EGL_NV_stream_consumer_eglimage */ + +/* ----------- EGL_NV_stream_consumer_eglimage_use_scanout_attrib ---------- */ + +#ifndef EGL_NV_stream_consumer_eglimage_use_scanout_attrib +#define EGL_NV_stream_consumer_eglimage_use_scanout_attrib 1 + +#define EGL_STREAM_CONSUMER_IMAGE_USE_SCANOUT_NV 0x3378 + +#define EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib EGLEW_GET_VAR(__EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib) + +#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */ + /* ------------------ EGL_NV_stream_consumer_gltexture_yuv ----------------- */ #ifndef EGL_NV_stream_consumer_gltexture_yuv @@ -2554,6 +2782,7 @@ typedef EGLSyncKHR ( * PFNEGLCREATESTREAMSYNCNVPROC) (EGLDisplay dpy, EGLStreamK #ifndef EGL_NV_sync #define EGL_NV_sync 1 +#define EGL_NO_SYNC_NV EGL_CAST(EGLSyncNV,0) #define EGL_SYNC_FLUSH_COMMANDS_BIT_NV 0x0001 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6 #define EGL_SYNC_STATUS_NV 0x30E7 @@ -2611,6 +2840,28 @@ typedef EGLuint64NV ( * PFNEGLGETSYSTEMTIMENVPROC) (void); #endif /* EGL_NV_triple_buffer */ +/* ---------------------- EGL_QNX_image_native_buffer ---------------------- */ + +#ifndef EGL_QNX_image_native_buffer +#define EGL_QNX_image_native_buffer 1 + +#define EGL_NATIVE_BUFFER_QNX 0x3551 + +#define EGLEW_QNX_image_native_buffer EGLEW_GET_VAR(__EGLEW_QNX_image_native_buffer) + +#endif /* EGL_QNX_image_native_buffer */ + +/* ------------------------ EGL_QNX_platform_screen ------------------------ */ + +#ifndef EGL_QNX_platform_screen +#define EGL_QNX_platform_screen 1 + +#define EGL_PLATFORM_SCREEN_QNX 0x3550 + +#define EGLEW_QNX_platform_screen EGLEW_GET_VAR(__EGLEW_QNX_platform_screen) + +#endif /* EGL_QNX_platform_screen */ + /* --------------------- EGL_TIZEN_image_native_buffer --------------------- */ #ifndef EGL_TIZEN_image_native_buffer @@ -2742,6 +2993,8 @@ EGLEW_FUN_EXPORT PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROI EGLEW_FUN_EXPORT PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE; +EGLEW_FUN_EXPORT PFNEGLGETMSCRATEANGLEPROC __eglewGetMscRateANGLE; + EGLEW_FUN_EXPORT PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT; EGLEW_FUN_EXPORT PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT; @@ -2754,10 +3007,14 @@ EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEX EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT; +EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEBINARYEXTPROC __eglewQueryDeviceBinaryEXT; + EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT; +EGLEW_FUN_EXPORT PFNEGLDESTROYDISPLAYEXTPROC __eglewDestroyDisplayEXT; + EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT; @@ -2776,6 +3033,8 @@ EGLEW_FUN_EXPORT PFNEGLGETPLATFORMDISPLAYEXTPROC __eglewGetPlatformDisplayEXT; EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT; +EGLEW_FUN_EXPORT PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC __eglewQuerySupportedCompressionRatesEXT; + EGLEW_FUN_EXPORT PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT; EGLEW_FUN_EXPORT PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT; @@ -2852,6 +3111,11 @@ EGLEW_FUN_EXPORT PFNEGLQUERYNATIVEWINDOWNVPROC __eglewQueryNativeWindowNV; EGLEW_FUN_EXPORT PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV; +EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC __eglewQueryStreamConsumerEventNV; +EGLEW_FUN_EXPORT PFNEGLSTREAMACQUIREIMAGENVPROC __eglewStreamAcquireImageNV; +EGLEW_FUN_EXPORT PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC __eglewStreamImageConsumerConnectNV; +EGLEW_FUN_EXPORT PFNEGLSTREAMRELEASEIMAGENVPROC __eglewStreamReleaseImageNV; + EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV; EGLEW_FUN_EXPORT PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV; @@ -2896,10 +3160,12 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_image_native_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_native_fence_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_presentation_time; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_recordable; +EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_telemetry_hint; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_d3d_share_handle_client_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_device_d3d; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_query_surface_pointer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle; +EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_sync_control_rate; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_window_fixed_size; EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_image_format; EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_implicit_external_sync; @@ -2909,12 +3175,19 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_buffer_age; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_extensions; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_compositor; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_config_select_group; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_create_context_robustness; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm_render_node; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_enumeration; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_openwf; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_persistent_id; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_query; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_query_name; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_display_alloc; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_explicit_device; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_hlg; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_display_p3; @@ -2935,11 +3208,15 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_device; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_wayland; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_x11; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_xcb; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_present_opaque; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_content; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_surface; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_query_reset_notification_strategy; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_stream_consumer_egloutput; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_CTA861_3_metadata; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_compression; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_swap_buffers_with_damage; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_sync_reuse; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_yuv_surface; @@ -3008,6 +3285,8 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_convert_rounding; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_sub_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_quadruple_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_robustness_video_memory_purge; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_eglimage; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_display; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_object; @@ -3030,6 +3309,8 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_system_time; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_triple_buffer; +EGLEW_VAR_EXPORT GLboolean __EGLEW_QNX_image_native_buffer; +EGLEW_VAR_EXPORT GLboolean __EGLEW_QNX_platform_screen; EGLEW_VAR_EXPORT GLboolean __EGLEW_TIZEN_image_native_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_TIZEN_image_native_surface; EGLEW_VAR_EXPORT GLboolean __EGLEW_WL_bind_wayland_display; diff --git a/include/GL/glew.h b/include/GL/glew.h index 234591b..5db218c 100644 --- a/include/GL/glew.h +++ b/include/GL/glew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -81,7 +81,7 @@ #define __glew_h__ #define __GLEW_H__ -#if defined(__gl_h_) || defined(__GL_H__) || defined(_GL_H) || defined(__X_GL_H) +#if defined(__gl_h_) || defined(__GL_H__) || defined(_GL_H) || defined(__gl_gl_h_) || defined(__X_GL_H) #error gl.h included before glew.h #endif #if defined(__gl2_h_) @@ -104,6 +104,7 @@ #define __gl2_h_ #define __GL_H__ #define _GL_H +#define __gl_gl_h_ #define __gltypes_h_ #define __REGAL_H__ #define __X_GL_H @@ -141,11 +142,6 @@ # define APIENTRY # endif #endif -#ifndef GLAPI -# if defined(__MINGW32__) || defined(__CYGWIN__) -# define GLAPI extern -# endif -#endif /* */ #ifndef CALLBACK #define GLEW_CALLBACK_DEFINED @@ -2660,7 +2656,7 @@ typedef void (GLAPIENTRY *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum sev typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, void *userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf); -typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message); +typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLenum* severities, GLuint* ids, GLsizei* lengths, GLchar* message); #define glDebugMessageCallbackAMD GLEW_GET_FUN(__glewDebugMessageCallbackAMD) #define glDebugMessageEnableAMD GLEW_GET_FUN(__glewDebugMessageEnableAMD) @@ -6210,9 +6206,11 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSARBPROC) (GLint x, GLint y, GLsizei w #define GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB 0x9342 #define GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB 0x9343 +typedef void (GLAPIENTRY * PFNGLEVALUATEDEPTHVALUESARBPROC) (void); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLenum target, GLuint start, GLsizei count, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v); +#define glEvaluateDepthValuesARB GLEW_GET_FUN(__glewEvaluateDepthValuesARB) #define glFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewFramebufferSampleLocationsfvARB) #define glNamedFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewNamedFramebufferSampleLocationsfvARB) @@ -8554,6 +8552,27 @@ typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p); #endif /* GL_ARM_rgba8 */ +/* --------------------- GL_ARM_shader_core_properties --------------------- */ + +#ifndef GL_ARM_shader_core_properties +#define GL_ARM_shader_core_properties 1 + +#define GL_SHADER_CORE_COUNT_ARM 0x96F0 +#define GL_SHADER_CORE_ACTIVE_COUNT_ARM 0x96F1 +#define GL_SHADER_CORE_PRESENT_MASK_ARM 0x96F2 +#define GL_SHADER_CORE_MAX_WARP_COUNT_ARM 0x96F3 +#define GL_SHADER_CORE_PIXEL_RATE_ARM 0x96F4 +#define GL_SHADER_CORE_TEXEL_RATE_ARM 0x96F5 +#define GL_SHADER_CORE_FMA_RATE_ARM 0x96F6 + +typedef void (GLAPIENTRY * PFNGLMAXACTIVESHADERCORESARMPROC) (GLuint count); + +#define glMaxActiveShaderCoresARM GLEW_GET_FUN(__glewMaxActiveShaderCoresARM) + +#define GLEW_ARM_shader_core_properties GLEW_GET_VAR(__GLEW_ARM_shader_core_properties) + +#endif /* GL_ARM_shader_core_properties */ + /* -------------------- GL_ARM_shader_framebuffer_fetch -------------------- */ #ifndef GL_ARM_shader_framebuffer_fetch @@ -9220,6 +9239,19 @@ typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC) (GLuint tex #endif /* GL_EXT_EGL_image_storage */ +/* ------------------ GL_EXT_EGL_image_storage_compression ----------------- */ + +#ifndef GL_EXT_EGL_image_storage_compression +#define GL_EXT_EGL_image_storage_compression 1 + +#define GL_SURFACE_COMPRESSION_EXT 0x96C0 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x96C1 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x96C2 + +#define GLEW_EXT_EGL_image_storage_compression GLEW_GET_VAR(__GLEW_EXT_EGL_image_storage_compression) + +#endif /* GL_EXT_EGL_image_storage_compression */ + /* ---------------------------- GL_EXT_EGL_sync ---------------------------- */ #ifndef GL_EXT_EGL_sync @@ -9437,10 +9469,8 @@ typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); #define GL_BUFFER_STORAGE_FLAGS_EXT 0x8220 typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEEXTPROC) (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags); -typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags); #define glBufferStorageEXT GLEW_GET_FUN(__glewBufferStorageEXT) -#define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT) #define GLEW_EXT_buffer_storage GLEW_GET_VAR(__GLEW_EXT_buffer_storage) @@ -10010,6 +10040,7 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum ta typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param); @@ -10225,6 +10256,7 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, G #define glTextureImage1DEXT GLEW_GET_FUN(__glewTextureImage1DEXT) #define glTextureImage2DEXT GLEW_GET_FUN(__glewTextureImage2DEXT) #define glTextureImage3DEXT GLEW_GET_FUN(__glewTextureImage3DEXT) +#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT) #define glTextureParameterIivEXT GLEW_GET_FUN(__glewTextureParameterIivEXT) #define glTextureParameterIuivEXT GLEW_GET_FUN(__glewTextureParameterIuivEXT) #define glTextureParameterfEXT GLEW_GET_FUN(__glewTextureParameterfEXT) @@ -10415,7 +10447,7 @@ typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIEXTPROC) (GLenum target, GLuint i typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); -typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex); #define glDrawElementsBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsBaseVertexEXT) #define glDrawElementsInstancedBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexEXT) @@ -10599,6 +10631,71 @@ typedef void (GLAPIENTRY * PFNGLLIGHTENVIEXTPROC) (GLenum pname, GLint param); #endif /* GL_EXT_fragment_lighting */ +/* ---------------------- GL_EXT_fragment_shading_rate --------------------- */ + +#ifndef GL_EXT_fragment_shading_rate +#define GL_EXT_fragment_shading_rate 1 + +#define GL_FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED_EXT 0x8F6F +#define GL_SHADING_RATE_1X1_PIXELS_EXT 0x96A6 +#define GL_SHADING_RATE_1X2_PIXELS_EXT 0x96A7 +#define GL_SHADING_RATE_2X1_PIXELS_EXT 0x96A8 +#define GL_SHADING_RATE_2X2_PIXELS_EXT 0x96A9 +#define GL_SHADING_RATE_1X4_PIXELS_EXT 0x96AA +#define GL_SHADING_RATE_4X1_PIXELS_EXT 0x96AB +#define GL_SHADING_RATE_4X2_PIXELS_EXT 0x96AC +#define GL_SHADING_RATE_2X4_PIXELS_EXT 0x96AD +#define GL_SHADING_RATE_4X4_PIXELS_EXT 0x96AE +#define GL_SHADING_RATE_EXT 0x96D0 +#define GL_SHADING_RATE_ATTACHMENT_EXT 0x96D1 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_EXT 0x96D2 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_EXT 0x96D3 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_EXT 0x96D4 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_EXT 0x96D5 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_EXT 0x96D6 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D7 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D8 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96D9 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96DA +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO_EXT 0x96DB +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS_EXT 0x96DC +#define GL_FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED_EXT 0x96DD +#define GL_FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED_EXT 0x96DE +#define GL_FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED_EXT 0x96DF +#define GL_FRAGMENT_SHADING_RATE_PRIMITIVE_RATE_WITH_MULTI_VIEWPORT_SUPPORTED_EXT 0x9780 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSHADINGRATEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTSHADINGRATESEXTPROC) (GLsizei samples, GLsizei maxCount, GLsizei* count, GLenum *shadingRates); +typedef void (GLAPIENTRY * PFNGLSHADINGRATECOMBINEROPSEXTPROC) (GLenum combinerOp0, GLenum combinerOp1); +typedef void (GLAPIENTRY * PFNGLSHADINGRATEEXTPROC) (GLenum rate); + +#define glFramebufferShadingRateEXT GLEW_GET_FUN(__glewFramebufferShadingRateEXT) +#define glGetFragmentShadingRatesEXT GLEW_GET_FUN(__glewGetFragmentShadingRatesEXT) +#define glShadingRateCombinerOpsEXT GLEW_GET_FUN(__glewShadingRateCombinerOpsEXT) +#define glShadingRateEXT GLEW_GET_FUN(__glewShadingRateEXT) + +#define GLEW_EXT_fragment_shading_rate GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate) + +#endif /* GL_EXT_fragment_shading_rate */ + +/* ---------------- GL_EXT_fragment_shading_rate_attachment ---------------- */ + +#ifndef GL_EXT_fragment_shading_rate_attachment +#define GL_EXT_fragment_shading_rate_attachment 1 + +#define GLEW_EXT_fragment_shading_rate_attachment GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate_attachment) + +#endif /* GL_EXT_fragment_shading_rate_attachment */ + +/* ----------------- GL_EXT_fragment_shading_rate_primitive ---------------- */ + +#ifndef GL_EXT_fragment_shading_rate_primitive +#define GL_EXT_fragment_shading_rate_primitive 1 + +#define GLEW_EXT_fragment_shading_rate_primitive GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate_primitive) + +#endif /* GL_EXT_fragment_shading_rate_primitive */ + /* ------------------------ GL_EXT_framebuffer_blit ------------------------ */ #ifndef GL_EXT_framebuffer_blit @@ -10617,6 +10714,21 @@ typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY #endif /* GL_EXT_framebuffer_blit */ +/* --------------------- GL_EXT_framebuffer_blit_layers -------------------- */ + +#ifndef GL_EXT_framebuffer_blit_layers +#define GL_EXT_framebuffer_blit_layers 1 + +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERLAYEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter); +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERLAYERSEXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + +#define glBlitFramebufferLayerEXT GLEW_GET_FUN(__glewBlitFramebufferLayerEXT) +#define glBlitFramebufferLayersEXT GLEW_GET_FUN(__glewBlitFramebufferLayersEXT) + +#define GLEW_EXT_framebuffer_blit_layers GLEW_GET_VAR(__GLEW_EXT_framebuffer_blit_layers) + +#endif /* GL_EXT_framebuffer_blit_layers */ + /* --------------------- GL_EXT_framebuffer_multisample -------------------- */ #ifndef GL_EXT_framebuffer_multisample @@ -11265,6 +11377,92 @@ typedef void (GLAPIENTRY * PFNGLIMPORTMEMORYWIN32NAMEEXTPROC) (GLuint memory, GL #endif /* GL_EXT_memory_object_win32 */ +/* --------------------------- GL_EXT_mesh_shader -------------------------- */ + +#ifndef GL_EXT_mesh_shader +#define GL_EXT_mesh_shader 1 + +#define GL_MESH_SHADER_BIT_EXT 0x00000040 +#define GL_TASK_SHADER_BIT_EXT 0x00000080 +#define GL_MAX_MESH_UNIFORM_BLOCKS_EXT 0x8E60 +#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_EXT 0x8E61 +#define GL_MAX_MESH_IMAGE_UNIFORMS_EXT 0x8E62 +#define GL_MAX_MESH_UNIFORM_COMPONENTS_EXT 0x8E63 +#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_EXT 0x8E64 +#define GL_MAX_MESH_ATOMIC_COUNTERS_EXT 0x8E65 +#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_EXT 0x8E66 +#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_EXT 0x8E67 +#define GL_MAX_TASK_UNIFORM_BLOCKS_EXT 0x8E68 +#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_EXT 0x8E69 +#define GL_MAX_TASK_IMAGE_UNIFORMS_EXT 0x8E6A +#define GL_MAX_TASK_UNIFORM_COMPONENTS_EXT 0x8E6B +#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_EXT 0x8E6C +#define GL_MAX_TASK_ATOMIC_COUNTERS_EXT 0x8E6D +#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_EXT 0x8E6E +#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_EXT 0x8E6F +#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_EXT 0x92DF +#define GL_MAX_MESH_OUTPUT_VERTICES_EXT 0x9538 +#define GL_MESH_WORK_GROUP_SIZE_EXT 0x953E +#define GL_TASK_WORK_GROUP_SIZE_EXT 0x953F +#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_EXT 0x9543 +#define GL_MAX_MESH_MULTIVIEW_VIEW_COUNT_EXT 0x9557 +#define GL_MESH_SHADER_EXT 0x9559 +#define GL_TASK_SHADER_EXT 0x955A +#define GL_MESH_VERTICES_OUT_EXT 0x9579 +#define GL_MESH_PRIMITIVES_OUT_EXT 0x957A +#define GL_MESH_OUTPUT_TYPE_EXT 0x957B +#define GL_MESH_SUBROUTINE_EXT 0x957C +#define GL_TASK_SUBROUTINE_EXT 0x957D +#define GL_MESH_SUBROUTINE_UNIFORM_EXT 0x957E +#define GL_TASK_SUBROUTINE_UNIFORM_EXT 0x957F +#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_EXT 0x959C +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_EXT 0x959D +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_EXT 0x959E +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_EXT 0x959F +#define GL_REFERENCED_BY_MESH_SHADER_EXT 0x95A0 +#define GL_REFERENCED_BY_TASK_SHADER_EXT 0x95A1 +#define GL_MAX_TASK_WORK_GROUP_TOTAL_COUNT_EXT 0x9740 +#define GL_MAX_MESH_WORK_GROUP_TOTAL_COUNT_EXT 0x9741 +#define GL_MAX_TASK_PAYLOAD_SIZE_EXT 0x9742 +#define GL_MAX_TASK_SHARED_MEMORY_SIZE_EXT 0x9743 +#define GL_MAX_MESH_SHARED_MEMORY_SIZE_EXT 0x9744 +#define GL_MAX_TASK_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9745 +#define GL_MAX_MESH_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9746 +#define GL_MAX_MESH_OUTPUT_MEMORY_SIZE_EXT 0x9747 +#define GL_MAX_MESH_PAYLOAD_AND_OUTPUT_MEMORY_SIZE_EXT 0x9748 +#define GL_MAX_MESH_OUTPUT_COMPONENTS_EXT 0x9749 +#define GL_MAX_MESH_OUTPUT_LAYERS_EXT 0x974A +#define GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT 0x974B +#define GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT 0x974C +#define GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT 0x974D +#define GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT 0x974E +#define GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT 0x974F +#define GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT 0x9750 +#define GL_MAX_TASK_WORK_GROUP_COUNT_EXT 0x9751 +#define GL_MAX_MESH_WORK_GROUP_COUNT_EXT 0x9752 +#define GL_TASK_SHADER_INVOCATIONS_EXT 0x9753 +#define GL_MESH_SHADER_INVOCATIONS_EXT 0x9754 +#define GL_MESH_PRIMITIVES_GENERATED_EXT 0x9755 +#define GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT 0x9756 +#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_EXT 0x9757 +#define GL_MAX_MESH_WORK_GROUP_SIZE_EXT 0x9758 +#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_EXT 0x9759 +#define GL_MAX_TASK_WORK_GROUP_SIZE_EXT 0x975A + +typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSEXTPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride); + +#define glDrawMeshTasksEXT GLEW_GET_FUN(__glewDrawMeshTasksEXT) +#define glDrawMeshTasksIndirectEXT GLEW_GET_FUN(__glewDrawMeshTasksIndirectEXT) +#define glMultiDrawMeshTasksIndirectCountEXT GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectCountEXT) +#define glMultiDrawMeshTasksIndirectEXT GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectEXT) + +#define GLEW_EXT_mesh_shader GLEW_GET_VAR(__GLEW_EXT_mesh_shader) + +#endif /* GL_EXT_mesh_shader */ + /* ------------------------- GL_EXT_misc_attribute ------------------------- */ #ifndef GL_EXT_misc_attribute @@ -11798,10 +11996,12 @@ typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean #define GL_NO_RESET_NOTIFICATION_EXT 0x8261 #define GL_CONTEXT_ROBUST_ACCESS_EXT 0x90F3 +typedef GLenum (GLAPIENTRY * PFNGLGETGRAPHICSRESETSTATUSEXTPROC) (void); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params); typedef void (GLAPIENTRY * PFNGLREADNPIXELSEXTPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data); +#define glGetGraphicsResetStatusEXT GLEW_GET_FUN(__glewGetGraphicsResetStatusEXT) #define glGetnUniformfvEXT GLEW_GET_FUN(__glewGetnUniformfvEXT) #define glGetnUniformivEXT GLEW_GET_FUN(__glewGetnUniformivEXT) #define glReadnPixelsEXT GLEW_GET_FUN(__glewReadnPixelsEXT) @@ -11966,6 +12166,15 @@ typedef void (GLAPIENTRY * PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC) (GLuint semapho #endif /* GL_EXT_semaphore_win32 */ +/* --------------------- GL_EXT_separate_depth_stencil --------------------- */ + +#ifndef GL_EXT_separate_depth_stencil +#define GL_EXT_separate_depth_stencil 1 + +#define GLEW_EXT_separate_depth_stencil GLEW_GET_VAR(__GLEW_EXT_separate_depth_stencil) + +#endif /* GL_EXT_separate_depth_stencil */ + /* --------------------- GL_EXT_separate_shader_objects -------------------- */ #ifndef GL_EXT_separate_shader_objects @@ -11998,6 +12207,15 @@ typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint pr #endif /* GL_EXT_separate_specular_color */ +/* -------------------------- GL_EXT_shader_clock -------------------------- */ + +#ifndef GL_EXT_shader_clock +#define GL_EXT_shader_clock 1 + +#define GLEW_EXT_shader_clock GLEW_GET_VAR(__GLEW_EXT_shader_clock) + +#endif /* GL_EXT_shader_clock */ + /* -------------------- GL_EXT_shader_framebuffer_fetch -------------------- */ #ifndef GL_EXT_shader_framebuffer_fetch @@ -12183,6 +12401,24 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) ( #endif /* GL_EXT_shader_pixel_local_storage2 */ +/* ---------------------- GL_EXT_shader_realtime_clock --------------------- */ + +#ifndef GL_EXT_shader_realtime_clock +#define GL_EXT_shader_realtime_clock 1 + +#define GLEW_EXT_shader_realtime_clock GLEW_GET_VAR(__GLEW_EXT_shader_realtime_clock) + +#endif /* GL_EXT_shader_realtime_clock */ + +/* -------------------- GL_EXT_shader_samples_identical -------------------- */ + +#ifndef GL_EXT_shader_samples_identical +#define GL_EXT_shader_samples_identical 1 + +#define GLEW_EXT_shader_samples_identical GLEW_GET_VAR(__GLEW_EXT_shader_samples_identical) + +#endif /* GL_EXT_shader_samples_identical */ + /* ----------------------- GL_EXT_shader_texture_lod ----------------------- */ #ifndef GL_EXT_shader_texture_lod @@ -12192,6 +12428,15 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) ( #endif /* GL_EXT_shader_texture_lod */ +/* --------------------- GL_EXT_shader_texture_samples --------------------- */ + +#ifndef GL_EXT_shader_texture_samples +#define GL_EXT_shader_texture_samples 1 + +#define GLEW_EXT_shader_texture_samples GLEW_GET_VAR(__GLEW_EXT_shader_texture_samples) + +#endif /* GL_EXT_shader_texture_samples */ + /* -------------------------- GL_EXT_shadow_funcs -------------------------- */ #ifndef GL_EXT_shadow_funcs @@ -12249,10 +12494,8 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) ( #define GL_NUM_SPARSE_LEVELS_EXT 0x91AA typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); -typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); #define glTexPageCommitmentEXT GLEW_GET_FUN(__glewTexPageCommitmentEXT) -#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT) #define GLEW_EXT_sparse_texture GLEW_GET_VAR(__GLEW_EXT_sparse_texture) @@ -12849,6 +13092,7 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #define GL_EXT_texture_format_BGRA8888 1 #define GL_BGRA_EXT 0x80E1 +#define GL_BGRA8_EXT 0x93A1 #define GLEW_EXT_texture_format_BGRA8888 GLEW_GET_VAR(__GLEW_EXT_texture_format_BGRA8888) @@ -13239,6 +13483,38 @@ typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum #endif /* GL_EXT_texture_storage */ +/* ------------------- GL_EXT_texture_storage_compression ------------------ */ + +#ifndef GL_EXT_texture_storage_compression +#define GL_EXT_texture_storage_compression 1 + +#define GL_NUM_SURFACE_COMPRESSION_FIXED_RATES_EXT 0x8F6E +#define GL_SURFACE_COMPRESSION_EXT 0x96C0 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x96C1 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x96C2 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT 0x96C4 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT 0x96C5 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT 0x96C6 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT 0x96C7 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT 0x96C8 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT 0x96C9 +#define GL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT 0x96CA +#define GL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT 0x96CB +#define GL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT 0x96CC +#define GL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT 0x96CD +#define GL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT 0x96CE +#define GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT 0x96CF + +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEATTRIBS2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, const GLint* attrib_list); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEATTRIBS3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, const GLint* attrib_list); + +#define glTexStorageAttribs2DEXT GLEW_GET_FUN(__glewTexStorageAttribs2DEXT) +#define glTexStorageAttribs3DEXT GLEW_GET_FUN(__glewTexStorageAttribs3DEXT) + +#define GLEW_EXT_texture_storage_compression GLEW_GET_VAR(__GLEW_EXT_texture_storage_compression) + +#endif /* GL_EXT_texture_storage_compression */ + /* ------------------------- GL_EXT_texture_swizzle ------------------------ */ #ifndef GL_EXT_texture_swizzle @@ -13864,6 +14140,28 @@ typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, #endif /* GL_HP_texture_lighting */ +/* ------------------------ GL_HUAWEI_program_binary ----------------------- */ + +#ifndef GL_HUAWEI_program_binary +#define GL_HUAWEI_program_binary 1 + +#define GL_HUAWEI_PROGRAM_BINARY 0x9771 + +#define GLEW_HUAWEI_program_binary GLEW_GET_VAR(__GLEW_HUAWEI_program_binary) + +#endif /* GL_HUAWEI_program_binary */ + +/* ------------------------ GL_HUAWEI_shader_binary ------------------------ */ + +#ifndef GL_HUAWEI_shader_binary +#define GL_HUAWEI_shader_binary 1 + +#define GL_HUAWEI_SHADER_BINARY 0x9770 + +#define GLEW_HUAWEI_shader_binary GLEW_GET_VAR(__GLEW_HUAWEI_shader_binary) + +#endif /* GL_HUAWEI_shader_binary */ + /* --------------------------- GL_IBM_cull_vertex -------------------------- */ #ifndef GL_IBM_cull_vertex @@ -14042,6 +14340,17 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t #endif /* GL_IMG_program_binary */ +/* ------------------- GL_IMG_pvric_end_to_end_signature ------------------- */ + +#ifndef GL_IMG_pvric_end_to_end_signature +#define GL_IMG_pvric_end_to_end_signature 1 + +#define GL_PVRIC_SIGNATURE_MISMATCH_IMG 0x8EA3 + +#define GLEW_IMG_pvric_end_to_end_signature GLEW_GET_VAR(__GLEW_IMG_pvric_end_to_end_signature) + +#endif /* GL_IMG_pvric_end_to_end_signature */ + /* --------------------------- GL_IMG_read_format -------------------------- */ #ifndef GL_IMG_read_format @@ -14121,6 +14430,19 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t #endif /* GL_IMG_texture_filter_cubic */ +/* --------------------- GL_IMG_tile_region_protection --------------------- */ + +#ifndef GL_IMG_tile_region_protection +#define GL_IMG_tile_region_protection 1 + +#define GL_TRP_IMG 0x8EA0 +#define GL_TRP_ERROR_CONTEXT_RESET_IMG 0x8EA1 +#define GL_TRP_UNSUPPORTED_CONTEXT_IMG 0x8EA2 + +#define GLEW_IMG_tile_region_protection GLEW_GET_VAR(__GLEW_IMG_tile_region_protection) + +#endif /* GL_IMG_tile_region_protection */ + /* -------------------------- GL_INGR_color_clamp -------------------------- */ #ifndef GL_INGR_color_clamp @@ -14186,6 +14508,10 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t #ifndef GL_INTEL_framebuffer_CMAA #define GL_INTEL_framebuffer_CMAA 1 +typedef void (GLAPIENTRY * PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC) (void); + +#define glApplyFramebufferAttachmentCMAAINTEL GLEW_GET_FUN(__glewApplyFramebufferAttachmentCMAAINTEL) + #define GLEW_INTEL_framebuffer_CMAA GLEW_GET_VAR(__GLEW_INTEL_framebuffer_CMAA) #endif /* GL_INTEL_framebuffer_CMAA */ @@ -14691,6 +15017,29 @@ typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, G #endif /* GL_MESAX_texture_stack */ +/* ------------------------------ GL_MESA_bgra ----------------------------- */ + +#ifndef GL_MESA_bgra +#define GL_MESA_bgra 1 + +#define GL_BGR_EXT 0x80E0 +#define GL_BGRA_EXT 0x80E1 + +#define GLEW_MESA_bgra GLEW_GET_VAR(__GLEW_MESA_bgra) + +#endif /* GL_MESA_bgra */ + +/* ----------------------- GL_MESA_framebuffer_flip_x ---------------------- */ + +#ifndef GL_MESA_framebuffer_flip_x +#define GL_MESA_framebuffer_flip_x 1 + +#define GL_FRAMEBUFFER_FLIP_X_MESA 0x8BBC + +#define GLEW_MESA_framebuffer_flip_x GLEW_GET_VAR(__GLEW_MESA_framebuffer_flip_x) + +#endif /* GL_MESA_framebuffer_flip_x */ + /* ----------------------- GL_MESA_framebuffer_flip_y ---------------------- */ #ifndef GL_MESA_framebuffer_flip_y @@ -14708,6 +15057,17 @@ typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC) (GLenum targe #endif /* GL_MESA_framebuffer_flip_y */ +/* ---------------------- GL_MESA_framebuffer_swap_xy ---------------------- */ + +#ifndef GL_MESA_framebuffer_swap_xy +#define GL_MESA_framebuffer_swap_xy 1 + +#define GL_FRAMEBUFFER_SWAP_XY_MESA 0x8BBD + +#define GLEW_MESA_framebuffer_swap_xy GLEW_GET_VAR(__GLEW_MESA_framebuffer_swap_xy) + +#endif /* GL_MESA_framebuffer_swap_xy */ + /* -------------------------- GL_MESA_pack_invert -------------------------- */ #ifndef GL_MESA_pack_invert @@ -14752,6 +15112,17 @@ typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void); #endif /* GL_MESA_shader_integer_functions */ +/* -------------------- GL_MESA_texture_const_bandwidth -------------------- */ + +#ifndef GL_MESA_texture_const_bandwidth +#define GL_MESA_texture_const_bandwidth 1 + +#define GL_CONST_BW_TILING_MESA 0x8BBE + +#define GLEW_MESA_texture_const_bandwidth GLEW_GET_VAR(__GLEW_MESA_texture_const_bandwidth) + +#endif /* GL_MESA_texture_const_bandwidth */ + /* ----------------------- GL_MESA_tile_raster_order ----------------------- */ #ifndef GL_MESA_tile_raster_order @@ -14923,10 +15294,12 @@ typedef void (GLAPIENTRY * PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC) (GLbitfield gpuMa #define GL_NVX_progress_fence 1 typedef void (GLAPIENTRY * PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC) (GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray); +typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRESSFENCENVXPROC) (void); typedef void (GLAPIENTRY * PFNGLSIGNALSEMAPHOREUI64NVXPROC) (GLuint signalGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray); typedef void (GLAPIENTRY * PFNGLWAITSEMAPHOREUI64NVXPROC) (GLuint waitGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray); #define glClientWaitSemaphoreui64NVX GLEW_GET_FUN(__glewClientWaitSemaphoreui64NVX) +#define glCreateProgressFenceNVX GLEW_GET_FUN(__glewCreateProgressFenceNVX) #define glSignalSemaphoreui64NVX GLEW_GET_FUN(__glewSignalSemaphoreui64NVX) #define glWaitSemaphoreui64NVX GLEW_GET_FUN(__glewWaitSemaphoreui64NVX) @@ -16404,6 +16777,25 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREATTACHMEMORYNVPROC) (GLuint texture, GLui #endif /* GL_NV_memory_attachment */ +/* ----------------------- GL_NV_memory_object_sparse ---------------------- */ + +#ifndef GL_NV_memory_object_sparse +#define GL_NV_memory_object_sparse 1 + +typedef void (GLAPIENTRY * PFNGLBUFFERPAGECOMMITMENTMEMNVPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit); +typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTMEMNVPROC) (GLenum target, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit); +typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC) (GLuint texture, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit); + +#define glBufferPageCommitmentMemNV GLEW_GET_FUN(__glewBufferPageCommitmentMemNV) +#define glNamedBufferPageCommitmentMemNV GLEW_GET_FUN(__glewNamedBufferPageCommitmentMemNV) +#define glTexPageCommitmentMemNV GLEW_GET_FUN(__glewTexPageCommitmentMemNV) +#define glTexturePageCommitmentMemNV GLEW_GET_FUN(__glewTexturePageCommitmentMemNV) + +#define GLEW_NV_memory_object_sparse GLEW_GET_VAR(__GLEW_NV_memory_object_sparse) + +#endif /* GL_NV_memory_object_sparse */ + /* --------------------------- GL_NV_mesh_shader --------------------------- */ #ifndef GL_NV_mesh_shader @@ -16828,7 +17220,7 @@ typedef void (GLAPIENTRY * PFNGLPATHCOVERDEPTHFUNCNVPROC) (GLenum zfunc); typedef void (GLAPIENTRY * PFNGLPATHDASHARRAYNVPROC) (GLuint path, GLsizei dashCount, const GLfloat* dashArray); typedef void (GLAPIENTRY * PFNGLPATHFOGGENNVPROC) (GLenum genMode); typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); -typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXRANGENVPROC) (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2]); +typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXRANGENVPROC) (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint* baseAndCount); typedef void (GLAPIENTRY * PFNGLPATHGLYPHRANGENVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef void (GLAPIENTRY * PFNGLPATHGLYPHSNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void*charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef GLenum (GLAPIENTRY * PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); @@ -17069,6 +17461,18 @@ typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); #endif /* GL_NV_primitive_restart */ +/* ---------------------- GL_NV_primitive_shading_rate --------------------- */ + +#ifndef GL_NV_primitive_shading_rate +#define GL_NV_primitive_shading_rate 1 + +#define GL_SHADING_RATE_IMAGE_PER_PRIMITIVE_NV 0x95B1 +#define GL_SHADING_RATE_IMAGE_PALETTE_COUNT_NV 0x95B2 + +#define GLEW_NV_primitive_shading_rate GLEW_GET_VAR(__GLEW_NV_primitive_shading_rate) + +#endif /* GL_NV_primitive_shading_rate */ + /* ------------------------ GL_NV_query_resource_tag ----------------------- */ #ifndef GL_NV_query_resource_tag @@ -17508,9 +17912,10 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou typedef void (GLAPIENTRY * PFNGLBINDSHADINGRATEIMAGENVPROC) (GLuint texture); typedef void (GLAPIENTRY * PFNGLGETSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint entry, GLenum* rate); typedef void (GLAPIENTRY * PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC) (GLenum rate, GLuint samples, GLuint index, GLint* location); -typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEBARRIERNVPROC) (GLenum order); +typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEBARRIERNVPROC) (GLboolean synchronize); typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint first, GLsizei count, const GLenum* rates); typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC) (GLenum rate, GLuint samples, const GLint* locations); +typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERNVPROC) (GLenum order); #define glBindShadingRateImageNV GLEW_GET_FUN(__glewBindShadingRateImageNV) #define glGetShadingRateImagePaletteNV GLEW_GET_FUN(__glewGetShadingRateImagePaletteNV) @@ -17518,6 +17923,7 @@ typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC) (GLenum rate #define glShadingRateImageBarrierNV GLEW_GET_FUN(__glewShadingRateImageBarrierNV) #define glShadingRateImagePaletteNV GLEW_GET_FUN(__glewShadingRateImagePaletteNV) #define glShadingRateSampleOrderCustomNV GLEW_GET_FUN(__glewShadingRateSampleOrderCustomNV) +#define glShadingRateSampleOrderNV GLEW_GET_FUN(__glewShadingRateSampleOrderNV) #define GLEW_NV_shading_rate_image GLEW_GET_VAR(__GLEW_NV_shading_rate_image) @@ -17928,6 +18334,29 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture #endif /* GL_NV_texture_shader3 */ +/* ------------------------ GL_NV_timeline_semaphore ----------------------- */ + +#ifndef GL_NV_timeline_semaphore +#define GL_NV_timeline_semaphore 1 + +#define GL_TIMELINE_SEMAPHORE_VALUE_NV 0x9595 +#define GL_SEMAPHORE_TYPE_NV 0x95B3 +#define GL_SEMAPHORE_TYPE_BINARY_NV 0x95B4 +#define GL_SEMAPHORE_TYPE_TIMELINE_NV 0x95B5 +#define GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV 0x95B6 + +typedef void (GLAPIENTRY * PFNGLCREATESEMAPHORESNVPROC) (GLsizei n, GLuint* semaphores); +typedef void (GLAPIENTRY * PFNGLGETSEMAPHOREPARAMETERIVNVPROC) (GLuint semaphore, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLSEMAPHOREPARAMETERIVNVPROC) (GLuint semaphore, GLenum pname, const GLint* params); + +#define glCreateSemaphoresNV GLEW_GET_FUN(__glewCreateSemaphoresNV) +#define glGetSemaphoreParameterivNV GLEW_GET_FUN(__glewGetSemaphoreParameterivNV) +#define glSemaphoreParameterivNV GLEW_GET_FUN(__glewSemaphoreParameterivNV) + +#define GLEW_NV_timeline_semaphore GLEW_GET_VAR(__GLEW_NV_timeline_semaphore) + +#endif /* GL_NV_timeline_semaphore */ + /* ------------------------ GL_NV_transform_feedback ----------------------- */ #ifndef GL_NV_transform_feedback @@ -18017,6 +18446,15 @@ typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void); #endif /* GL_NV_transform_feedback2 */ +/* ------------------- GL_NV_uniform_buffer_std430_layout ------------------ */ + +#ifndef GL_NV_uniform_buffer_std430_layout +#define GL_NV_uniform_buffer_std430_layout 1 + +#define GLEW_NV_uniform_buffer_std430_layout GLEW_GET_VAR(__GLEW_NV_uniform_buffer_std430_layout) + +#endif /* GL_NV_uniform_buffer_std430_layout */ + /* ------------------ GL_NV_uniform_buffer_unified_memory ------------------ */ #ifndef GL_NV_uniform_buffer_unified_memory @@ -19167,10 +19605,12 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFEROESPROC) (GLenum target); #define GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES 0x8B9E typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXOESPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC) (void); typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); #define glCurrentPaletteMatrixOES GLEW_GET_FUN(__glewCurrentPaletteMatrixOES) +#define glLoadPaletteFromModelViewMatrixOES GLEW_GET_FUN(__glewLoadPaletteFromModelViewMatrixOES) #define glMatrixIndexPointerOES GLEW_GET_FUN(__glewMatrixIndexPointerOES) #define glWeightPointerOES GLEW_GET_FUN(__glewWeightPointerOES) @@ -20100,6 +20540,19 @@ typedef GLboolean (GLAPIENTRY * PFNGLEXTISPROGRAMBINARYQCOMPROC) (GLuint program #endif /* GL_QCOM_extended_get2 */ +/* ---------------------- GL_QCOM_frame_extrapolation ---------------------- */ + +#ifndef GL_QCOM_frame_extrapolation +#define GL_QCOM_frame_extrapolation 1 + +typedef void (GLAPIENTRY * PFNGLEXTRAPOLATETEX2DQCOMPROC) (GLuint src1, GLuint src2, GLuint output, GLfloat scaleFactor); + +#define glExtrapolateTex2DQCOM GLEW_GET_FUN(__glewExtrapolateTex2DQCOM) + +#define GLEW_QCOM_frame_extrapolation GLEW_GET_VAR(__GLEW_QCOM_frame_extrapolation) + +#endif /* GL_QCOM_frame_extrapolation */ + /* ---------------------- GL_QCOM_framebuffer_foveated --------------------- */ #ifndef GL_QCOM_framebuffer_foveated @@ -20118,6 +20571,24 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC) (GLuint #endif /* GL_QCOM_framebuffer_foveated */ +/* ----------------------- GL_QCOM_motion_estimation ----------------------- */ + +#ifndef GL_QCOM_motion_estimation +#define GL_QCOM_motion_estimation 1 + +#define GL_MOTION_ESTIMATION_SEARCH_BLOCK_X_QCOM 0x8C90 +#define GL_MOTION_ESTIMATION_SEARCH_BLOCK_Y_QCOM 0x8C91 + +typedef void (GLAPIENTRY * PFNGLTEXESTIMATEMOTIONQCOMPROC) (GLuint ref, GLuint target, GLuint output); +typedef void (GLAPIENTRY * PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC) (GLuint ref, GLuint target, GLuint output, GLuint mask); + +#define glTexEstimateMotionQCOM GLEW_GET_FUN(__glewTexEstimateMotionQCOM) +#define glTexEstimateMotionRegionsQCOM GLEW_GET_FUN(__glewTexEstimateMotionRegionsQCOM) + +#define GLEW_QCOM_motion_estimation GLEW_GET_VAR(__GLEW_QCOM_motion_estimation) + +#endif /* GL_QCOM_motion_estimation */ + /* ---------------------- GL_QCOM_perfmon_global_mode ---------------------- */ #ifndef GL_QCOM_perfmon_global_mode @@ -20129,6 +20600,26 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC) (GLuint #endif /* GL_QCOM_perfmon_global_mode */ +/* ----------------------- GL_QCOM_render_sRGB_R8_RG8 ---------------------- */ + +#ifndef GL_QCOM_render_sRGB_R8_RG8 +#define GL_QCOM_render_sRGB_R8_RG8 1 + +#define GLEW_QCOM_render_sRGB_R8_RG8 GLEW_GET_VAR(__GLEW_QCOM_render_sRGB_R8_RG8) + +#endif /* GL_QCOM_render_sRGB_R8_RG8 */ + +/* --------------------- GL_QCOM_render_shared_exponent -------------------- */ + +#ifndef GL_QCOM_render_shared_exponent +#define GL_QCOM_render_shared_exponent 1 + +#define GL_RGB9_E5 0x8C3D + +#define GLEW_QCOM_render_shared_exponent GLEW_GET_VAR(__GLEW_QCOM_render_shared_exponent) + +#endif /* GL_QCOM_render_shared_exponent */ + /* -------------- GL_QCOM_shader_framebuffer_fetch_noncoherent ------------- */ #ifndef GL_QCOM_shader_framebuffer_fetch_noncoherent @@ -20153,6 +20644,28 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC) (void); #endif /* GL_QCOM_shader_framebuffer_fetch_rate */ +/* -------------------------- GL_QCOM_shading_rate ------------------------- */ + +#ifndef GL_QCOM_shading_rate +#define GL_QCOM_shading_rate 1 + +#define GL_SHADING_RATE_QCOM 0x96A4 +#define GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM 0x96A5 +#define GL_SHADING_RATE_1X1_PIXELS_QCOM 0x96A6 +#define GL_SHADING_RATE_1X2_PIXELS_QCOM 0x96A7 +#define GL_SHADING_RATE_2X1_PIXELS_QCOM 0x96A8 +#define GL_SHADING_RATE_2X2_PIXELS_QCOM 0x96A9 +#define GL_SHADING_RATE_4X2_PIXELS_QCOM 0x96AC +#define GL_SHADING_RATE_4X4_PIXELS_QCOM 0x96AE + +typedef void (GLAPIENTRY * PFNGLSHADINGRATEQCOMPROC) (GLenum rate); + +#define glShadingRateQCOM GLEW_GET_FUN(__glewShadingRateQCOM) + +#define GLEW_QCOM_shading_rate GLEW_GET_VAR(__GLEW_QCOM_shading_rate) + +#endif /* GL_QCOM_shading_rate */ + /* ------------------------ GL_QCOM_texture_foveated ----------------------- */ #ifndef GL_QCOM_texture_foveated @@ -20174,6 +20687,17 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC) (GLuint text #endif /* GL_QCOM_texture_foveated */ +/* ----------------------- GL_QCOM_texture_foveated2 ----------------------- */ + +#ifndef GL_QCOM_texture_foveated2 +#define GL_QCOM_texture_foveated2 1 + +#define GL_TEXTURE_FOVEATED_CUTOFF_DENSITY_QCOM 0x96A0 + +#define GLEW_QCOM_texture_foveated2 GLEW_GET_VAR(__GLEW_QCOM_texture_foveated2) + +#endif /* GL_QCOM_texture_foveated2 */ + /* --------------- GL_QCOM_texture_foveated_subsampled_layout -------------- */ #ifndef GL_QCOM_texture_foveated_subsampled_layout @@ -20186,6 +20710,17 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC) (GLuint text #endif /* GL_QCOM_texture_foveated_subsampled_layout */ +/* ------------------------ GL_QCOM_texture_lod_bias ----------------------- */ + +#ifndef GL_QCOM_texture_lod_bias +#define GL_QCOM_texture_lod_bias 1 + +#define GL_TEXTURE_LOD_BIAS_QCOM 0x8C96 + +#define GLEW_QCOM_texture_lod_bias GLEW_GET_VAR(__GLEW_QCOM_texture_lod_bias) + +#endif /* GL_QCOM_texture_lod_bias */ + /* ------------------------ GL_QCOM_tiled_rendering ------------------------ */ #ifndef GL_QCOM_tiled_rendering @@ -20245,6 +20780,18 @@ typedef void (GLAPIENTRY * PFNGLSTARTTILINGQCOMPROC) (GLuint x, GLuint y, GLuint #endif /* GL_QCOM_writeonly_rendering */ +/* ------------------------- GL_QCOM_ycbcr_degamma ------------------------- */ + +#ifndef GL_QCOM_ycbcr_degamma +#define GL_QCOM_ycbcr_degamma 1 + +#define GL_TEXTURE_Y_DEGAMMA_QCOM 0x9710 +#define GL_TEXTURE_CBCR_DEGAMMA_QCOM 0x9711 + +#define GLEW_QCOM_ycbcr_degamma GLEW_GET_VAR(__GLEW_QCOM_ycbcr_degamma) + +#endif /* GL_QCOM_ycbcr_degamma */ + /* ---------------------- GL_REGAL_ES1_0_compatibility --------------------- */ #ifndef GL_REGAL_ES1_0_compatibility @@ -23137,6 +23684,7 @@ GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB; GLEW_FUN_EXPORT PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB; +GLEW_FUN_EXPORT PFNGLEVALUATEDEPTHVALUESARBPROC __glewEvaluateDepthValuesARB; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB; @@ -23549,6 +24097,8 @@ GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB; +GLEW_FUN_EXPORT PFNGLMAXACTIVESHADERCORESARMPROC __glewMaxActiveShaderCoresARM; + GLEW_FUN_EXPORT PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI; GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI; @@ -23671,7 +24221,6 @@ GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT; GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT; -GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT; GLEW_FUN_EXPORT PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT; GLEW_FUN_EXPORT PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT; @@ -23912,6 +24461,7 @@ GLEW_FUN_EXPORT PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT; @@ -24008,8 +24558,16 @@ GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT; GLEW_FUN_EXPORT PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSHADINGRATEEXTPROC __glewFramebufferShadingRateEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTSHADINGRATESEXTPROC __glewGetFragmentShadingRatesEXT; +GLEW_FUN_EXPORT PFNGLSHADINGRATECOMBINEROPSEXTPROC __glewShadingRateCombinerOpsEXT; +GLEW_FUN_EXPORT PFNGLSHADINGRATEEXTPROC __glewShadingRateEXT; + GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT; +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERLAYEREXTPROC __glewBlitFramebufferLayerEXT; +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERLAYERSEXTPROC __glewBlitFramebufferLayersEXT; + GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT; GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT; @@ -24121,6 +24679,11 @@ GLEW_FUN_EXPORT PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT; GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT; GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT; +GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSEXTPROC __glewDrawMeshTasksEXT; +GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSINDIRECTEXTPROC __glewDrawMeshTasksIndirectEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC __glewMultiDrawMeshTasksIndirectCountEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC __glewMultiDrawMeshTasksIndirectEXT; + GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT; @@ -24164,6 +24727,7 @@ GLEW_FUN_EXPORT PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTable GLEW_FUN_EXPORT PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV; GLEW_FUN_EXPORT PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT; +GLEW_FUN_EXPORT PFNGLGETGRAPHICSRESETSTATUSEXTPROC __glewGetGraphicsResetStatusEXT; GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT; GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT; GLEW_FUN_EXPORT PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT; @@ -24216,7 +24780,6 @@ GLEW_FUN_EXPORT PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPi GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT; GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT; -GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT; GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT; @@ -24260,6 +24823,9 @@ GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEATTRIBS2DEXTPROC __glewTexStorageAttribs2DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEATTRIBS3DEXTPROC __glewTexStorageAttribs3DEXT; + GLEW_FUN_EXPORT PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT; @@ -24388,6 +24954,8 @@ GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferT GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG; +GLEW_FUN_EXPORT PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC __glewApplyFramebufferAttachmentCMAAINTEL; + GLEW_FUN_EXPORT PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL; GLEW_FUN_EXPORT PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL; GLEW_FUN_EXPORT PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL; @@ -24482,6 +25050,7 @@ GLEW_FUN_EXPORT PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX; GLEW_FUN_EXPORT PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX; GLEW_FUN_EXPORT PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC __glewClientWaitSemaphoreui64NVX; +GLEW_FUN_EXPORT PFNGLCREATEPROGRESSFENCENVXPROC __glewCreateProgressFenceNVX; GLEW_FUN_EXPORT PFNGLSIGNALSEMAPHOREUI64NVXPROC __glewSignalSemaphoreui64NVX; GLEW_FUN_EXPORT PFNGLWAITSEMAPHOREUI64NVXPROC __glewWaitSemaphoreui64NVX; @@ -24721,6 +25290,11 @@ GLEW_FUN_EXPORT PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectPar GLEW_FUN_EXPORT PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV; GLEW_FUN_EXPORT PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV; +GLEW_FUN_EXPORT PFNGLBUFFERPAGECOMMITMENTMEMNVPROC __glewBufferPageCommitmentMemNV; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC __glewNamedBufferPageCommitmentMemNV; +GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTMEMNVPROC __glewTexPageCommitmentMemNV; +GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC __glewTexturePageCommitmentMemNV; + GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV; GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV; GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV; @@ -24874,6 +25448,7 @@ GLEW_FUN_EXPORT PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSa GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV; GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV; GLEW_FUN_EXPORT PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV; +GLEW_FUN_EXPORT PFNGLSHADINGRATESAMPLEORDERNVPROC __glewShadingRateSampleOrderNV; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV; @@ -24891,6 +25466,10 @@ GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisa GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV; +GLEW_FUN_EXPORT PFNGLCREATESEMAPHORESNVPROC __glewCreateSemaphoresNV; +GLEW_FUN_EXPORT PFNGLGETSEMAPHOREPARAMETERIVNVPROC __glewGetSemaphoreParameterivNV; +GLEW_FUN_EXPORT PFNGLSEMAPHOREPARAMETERIVNVPROC __glewSemaphoreParameterivNV; + GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV; GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV; @@ -25097,6 +25676,7 @@ GLEW_FUN_EXPORT PFNGLMAPBUFFEROESPROC __glewMapBufferOES; GLEW_FUN_EXPORT PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES; GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES; +GLEW_FUN_EXPORT PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC __glewLoadPaletteFromModelViewMatrixOES; GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES; GLEW_FUN_EXPORT PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES; @@ -25173,11 +25753,18 @@ GLEW_FUN_EXPORT PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM; GLEW_FUN_EXPORT PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM; GLEW_FUN_EXPORT PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM; +GLEW_FUN_EXPORT PFNGLEXTRAPOLATETEX2DQCOMPROC __glewExtrapolateTex2DQCOM; + GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM; +GLEW_FUN_EXPORT PFNGLTEXESTIMATEMOTIONQCOMPROC __glewTexEstimateMotionQCOM; +GLEW_FUN_EXPORT PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC __glewTexEstimateMotionRegionsQCOM; + GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM; +GLEW_FUN_EXPORT PFNGLSHADINGRATEQCOMPROC __glewShadingRateQCOM; + GLEW_FUN_EXPORT PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM; GLEW_FUN_EXPORT PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM; @@ -25701,6 +26288,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_program_binary; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_shader_binary; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_rgba8; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_core_properties; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_ARM_texture_unnormalized_coordinates; @@ -25732,6 +26320,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_external_wrap_modes; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_storage_compression; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_sync; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_YUV_target; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; @@ -25781,7 +26370,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_float_blend; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_frag_depth; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate_attachment; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate_primitive; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit_layers; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object; @@ -25803,6 +26396,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_map_buffer_range; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_fd; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_win32; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_mesh_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_indirect; @@ -25843,8 +26437,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_fd; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_win32; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_clock; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_group_vote; @@ -25856,7 +26452,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_io_blocks; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_non_constant_global_initializers; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage2; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_realtime_clock; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_samples_identical; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_texture_samples; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_samplers; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette; @@ -25912,6 +26511,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shadow_lod; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_storage_compression; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_view; @@ -25934,6 +26534,8 @@ GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes; GLEW_VAR_EXPORT GLboolean __GLEW_HP_image_transform; GLEW_VAR_EXPORT GLboolean __GLEW_HP_occlusion_test; GLEW_VAR_EXPORT GLboolean __GLEW_HP_texture_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_HUAWEI_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_HUAWEI_shader_binary; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_cull_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_multimode_draw_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip; @@ -25944,12 +26546,14 @@ GLEW_VAR_EXPORT GLboolean __GLEW_IMG_bindless_texture; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_framebuffer_downsample; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_multisampled_render_to_texture; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_pvric_end_to_end_signature; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_read_format; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_shader_binary; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc2; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function; GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_filter_cubic; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_tile_region_protection; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_blackhole_render; @@ -25975,11 +26579,15 @@ GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_ldr; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d; GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region; GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_flip_x; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_flip_y; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_swap_xy; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_program_binary_formats; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_shader_integer_functions; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_texture_const_bandwidth; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_tile_raster_order; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture; @@ -26057,6 +26665,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_instanced_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_NV_internalformat_sample_query; GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_NV_memory_attachment; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_memory_object_sparse; GLEW_VAR_EXPORT GLboolean __GLEW_NV_mesh_shader; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; @@ -26077,6 +26686,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite; GLEW_VAR_EXPORT GLboolean __GLEW_NV_polygon_mode; GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video; GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_shading_rate; GLEW_VAR_EXPORT GLboolean __GLEW_NV_query_resource_tag; GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer_front; @@ -26126,8 +26736,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle_compressed; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_timeline_semaphore; GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback; GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_uniform_buffer_std430_layout; GLEW_VAR_EXPORT GLboolean __GLEW_NV_uniform_buffer_unified_memory; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop2; @@ -26221,14 +26833,22 @@ GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_binning_control; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_driver_control; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get2; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_frame_extrapolation; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_framebuffer_foveated; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_motion_estimation; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_perfmon_global_mode; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_render_sRGB_R8_RG8; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_render_shared_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shading_rate; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated2; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_lod_bias; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_tiled_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_writeonly_rendering; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_ycbcr_degamma; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_0_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_1_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_enable; @@ -26378,14 +26998,15 @@ GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; /* GLEW version info */ /* -VERSION 2.2.0 +VERSION 2.3.0 VERSION_MAJOR 2 -VERSION_MINOR 2 +VERSION_MINOR 3 VERSION_MICRO 0 */ /* API */ GLEWAPI GLenum GLEWAPIENTRY glewInit (void); +GLEWAPI GLenum GLEWAPIENTRY glewContextInit (void); GLEWAPI GLboolean GLEWAPIENTRY glewIsSupported (const char *name); #define glewIsExtensionSupported(x) glewIsSupported(x) diff --git a/include/GL/glxew.h b/include/GL/glxew.h index 0474ed5..2796b9b 100644 --- a/include/GL/glxew.h +++ b/include/GL/glxew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -675,6 +675,17 @@ typedef void ( * PFNGLXRELEASETEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, i #endif /* GLX_EXT_framebuffer_sRGB */ +/* ----------------------- GLX_EXT_get_drawable_type ----------------------- */ + +#ifndef GLX_EXT_get_drawable_type +#define GLX_EXT_get_drawable_type 1 + +#define GLX_DRAWABLE_TYPE 0x8010 + +#define GLXEW_EXT_get_drawable_type GLXEW_GET_VAR(__GLXEW_EXT_get_drawable_type) + +#endif /* GLX_EXT_get_drawable_type */ + /* ------------------------- GLX_EXT_import_context ------------------------ */ #ifndef GLX_EXT_import_context @@ -1760,6 +1771,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es2_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB; +GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_get_drawable_type; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_import_context; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_libglvnd; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_no_config_context; @@ -1811,7 +1823,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_get_transparent_index; GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_video_resize; /* ------------------------------------------------------------------------ */ -GLEWAPI GLenum GLEWAPIENTRY glxewInit (); +GLEWAPI GLenum GLEWAPIENTRY glxewInit (void); GLEWAPI GLboolean GLEWAPIENTRY glxewIsSupported (const char *name); #ifndef GLXEW_GET_VAR diff --git a/include/GL/wglew.h b/include/GL/wglew.h index 7e2d090..c7733b0 100644 --- a/include/GL/wglew.h +++ b/include/GL/wglew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -1446,7 +1446,7 @@ WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_video_output; WGLEW_VAR_EXPORT GLboolean __WGLEW_OML_sync_control; /* ------------------------------------------------------------------------- */ -GLEWAPI GLenum GLEWAPIENTRY wglewInit (); +GLEWAPI GLenum GLEWAPIENTRY wglewInit (void); GLEWAPI GLboolean GLEWAPIENTRY wglewIsSupported (const char *name); #ifndef WGLEW_GET_VAR diff --git a/src/glew.c b/src/glew.c index 967c5c9..463ea89 100644 --- a/src/glew.c +++ b/src/glew.c @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -38,7 +38,15 @@ #if defined(GLEW_OSMESA) # define GLAPI extern +# ifndef APIENTRY +# define APIENTRY +# define GLEW_APIENTRY_DEFINED +# endif # include +# ifdef GLEW_APIENTRY_DEFINED +# undef APIENTRY +# undef GLEW_APIENTRY_DEFINED +# endif #elif defined(GLEW_EGL) # include #elif defined(_WIN32) @@ -60,7 +68,7 @@ #if defined(GLEW_EGL) #elif defined(GLEW_REGAL) -/* In GLEW_REGAL mode we call direcly into the linked +/* In GLEW_REGAL mode we call directly into the linked libRegal.so glGetProcAddressREGAL for looking up the GL function pointers. */ @@ -102,7 +110,7 @@ void* dlGetProcAddress (const GLubyte* name) #include #include -#ifdef MAC_OS_X_VERSION_10_3 +#if defined(MAC_OS_X_VERSION_10_3) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3 #include @@ -152,7 +160,7 @@ void* NSGLGetProcAddress (const GLubyte *name) return NULL; #endif } -#endif /* MAC_OS_X_VERSION_10_3 */ +#endif /* defined(MAC_OS_X_VERSION_10_3) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3 */ #endif /* __APPLE__ */ /* @@ -253,7 +261,7 @@ static GLboolean _glewStrSame1 (const GLubyte** a, GLuint* na, const GLubyte* b, if(*na >= nb) { GLuint i=0; - while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + while (i < nb && (*a)[i] == b[i]) i++; if(i == nb) { *a = *a + nb; @@ -269,7 +277,7 @@ static GLboolean _glewStrSame2 (const GLubyte** a, GLuint* na, const GLubyte* b, if(*na >= nb) { GLuint i=0; - while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + while (i < nb && (*a)[i] == b[i]) i++; if(i == nb) { *a = *a + nb; @@ -285,7 +293,7 @@ static GLboolean _glewStrSame3 (const GLubyte** a, GLuint* na, const GLubyte* b, if(*na >= nb) { GLuint i=0; - while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + while (i < nb && (*a)[i] == b[i]) i++; if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t')) { *a = *a + nb; @@ -1179,6 +1187,7 @@ PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL; PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL; PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL; +PFNGLEVALUATEDEPTHVALUESARBPROC __glewEvaluateDepthValuesARB = NULL; PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB = NULL; PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB = NULL; @@ -1591,6 +1600,8 @@ PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL; PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL; PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL; +PFNGLMAXACTIVESHADERCORESARMPROC __glewMaxActiveShaderCoresARM = NULL; + PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL; PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL; @@ -1713,7 +1724,6 @@ PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL; PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL; PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT = NULL; -PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL; PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT = NULL; PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT = NULL; @@ -1954,6 +1964,7 @@ PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL; PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL; PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL; PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL; +PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL; PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL; PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL; PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL; @@ -2050,8 +2061,16 @@ PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL; PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL; PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL; +PFNGLFRAMEBUFFERSHADINGRATEEXTPROC __glewFramebufferShadingRateEXT = NULL; +PFNGLGETFRAGMENTSHADINGRATESEXTPROC __glewGetFragmentShadingRatesEXT = NULL; +PFNGLSHADINGRATECOMBINEROPSEXTPROC __glewShadingRateCombinerOpsEXT = NULL; +PFNGLSHADINGRATEEXTPROC __glewShadingRateEXT = NULL; + PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL; +PFNGLBLITFRAMEBUFFERLAYEREXTPROC __glewBlitFramebufferLayerEXT = NULL; +PFNGLBLITFRAMEBUFFERLAYERSEXTPROC __glewBlitFramebufferLayersEXT = NULL; + PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL; PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL; @@ -2163,6 +2182,11 @@ PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT = NULL; PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT = NULL; PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT = NULL; +PFNGLDRAWMESHTASKSEXTPROC __glewDrawMeshTasksEXT = NULL; +PFNGLDRAWMESHTASKSINDIRECTEXTPROC __glewDrawMeshTasksIndirectEXT = NULL; +PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC __glewMultiDrawMeshTasksIndirectCountEXT = NULL; +PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC __glewMultiDrawMeshTasksIndirectEXT = NULL; + PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL; PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL; @@ -2206,6 +2230,7 @@ PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV = NULL; PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV = NULL; PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT = NULL; +PFNGLGETGRAPHICSRESETSTATUSEXTPROC __glewGetGraphicsResetStatusEXT = NULL; PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT = NULL; PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT = NULL; PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT = NULL; @@ -2258,7 +2283,6 @@ PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPixelLocalStorageS PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT = NULL; PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT = NULL; -PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL; PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL; @@ -2302,6 +2326,9 @@ PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL; PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL; PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL; +PFNGLTEXSTORAGEATTRIBS2DEXTPROC __glewTexStorageAttribs2DEXT = NULL; +PFNGLTEXSTORAGEATTRIBS3DEXTPROC __glewTexStorageAttribs3DEXT = NULL; + PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT = NULL; PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL; @@ -2430,6 +2457,8 @@ PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferTextureLayerDowns PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG = NULL; +PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC __glewApplyFramebufferAttachmentCMAAINTEL = NULL; + PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL; PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL; PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL; @@ -2524,6 +2553,7 @@ PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX = NULL; PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX = NULL; PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC __glewClientWaitSemaphoreui64NVX = NULL; +PFNGLCREATEPROGRESSFENCENVXPROC __glewCreateProgressFenceNVX = NULL; PFNGLSIGNALSEMAPHOREUI64NVXPROC __glewSignalSemaphoreui64NVX = NULL; PFNGLWAITSEMAPHOREUI64NVXPROC __glewWaitSemaphoreui64NVX = NULL; @@ -2763,6 +2793,11 @@ PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectParameterNV = NULL; PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV = NULL; PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV = NULL; +PFNGLBUFFERPAGECOMMITMENTMEMNVPROC __glewBufferPageCommitmentMemNV = NULL; +PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC __glewNamedBufferPageCommitmentMemNV = NULL; +PFNGLTEXPAGECOMMITMENTMEMNVPROC __glewTexPageCommitmentMemNV = NULL; +PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC __glewTexturePageCommitmentMemNV = NULL; + PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV = NULL; PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV = NULL; PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV = NULL; @@ -2916,6 +2951,7 @@ PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSampleLocationivNV PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV = NULL; PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV = NULL; PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV = NULL; +PFNGLSHADINGRATESAMPLEORDERNVPROC __glewShadingRateSampleOrderNV = NULL; PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV = NULL; @@ -2933,6 +2969,10 @@ PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL; PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL; PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL; +PFNGLCREATESEMAPHORESNVPROC __glewCreateSemaphoresNV = NULL; +PFNGLGETSEMAPHOREPARAMETERIVNVPROC __glewGetSemaphoreParameterivNV = NULL; +PFNGLSEMAPHOREPARAMETERIVNVPROC __glewSemaphoreParameterivNV = NULL; + PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL; PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL; PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL; @@ -3139,6 +3179,7 @@ PFNGLMAPBUFFEROESPROC __glewMapBufferOES = NULL; PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES = NULL; PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES = NULL; +PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC __glewLoadPaletteFromModelViewMatrixOES = NULL; PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES = NULL; PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES = NULL; @@ -3215,11 +3256,18 @@ PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM = NULL; PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM = NULL; PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM = NULL; +PFNGLEXTRAPOLATETEX2DQCOMPROC __glewExtrapolateTex2DQCOM = NULL; + PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM = NULL; PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM = NULL; +PFNGLTEXESTIMATEMOTIONQCOMPROC __glewTexEstimateMotionQCOM = NULL; +PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC __glewTexEstimateMotionRegionsQCOM = NULL; + PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM = NULL; +PFNGLSHADINGRATEQCOMPROC __glewShadingRateQCOM = NULL; + PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM = NULL; PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM = NULL; @@ -3744,6 +3792,7 @@ GLboolean __GLEW_ARB_window_pos = GL_FALSE; GLboolean __GLEW_ARM_mali_program_binary = GL_FALSE; GLboolean __GLEW_ARM_mali_shader_binary = GL_FALSE; GLboolean __GLEW_ARM_rgba8 = GL_FALSE; +GLboolean __GLEW_ARM_shader_core_properties = GL_FALSE; GLboolean __GLEW_ARM_shader_framebuffer_fetch = GL_FALSE; GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil = GL_FALSE; GLboolean __GLEW_ARM_texture_unnormalized_coordinates = GL_FALSE; @@ -3775,6 +3824,7 @@ GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; GLboolean __GLEW_EXT_EGL_image_array = GL_FALSE; GLboolean __GLEW_EXT_EGL_image_external_wrap_modes = GL_FALSE; GLboolean __GLEW_EXT_EGL_image_storage = GL_FALSE; +GLboolean __GLEW_EXT_EGL_image_storage_compression = GL_FALSE; GLboolean __GLEW_EXT_EGL_sync = GL_FALSE; GLboolean __GLEW_EXT_YUV_target = GL_FALSE; GLboolean __GLEW_EXT_abgr = GL_FALSE; @@ -3824,7 +3874,11 @@ GLboolean __GLEW_EXT_float_blend = GL_FALSE; GLboolean __GLEW_EXT_fog_coord = GL_FALSE; GLboolean __GLEW_EXT_frag_depth = GL_FALSE; GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE; +GLboolean __GLEW_EXT_fragment_shading_rate = GL_FALSE; +GLboolean __GLEW_EXT_fragment_shading_rate_attachment = GL_FALSE; +GLboolean __GLEW_EXT_fragment_shading_rate_primitive = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_blit_layers = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE; @@ -3846,6 +3900,7 @@ GLboolean __GLEW_EXT_map_buffer_range = GL_FALSE; GLboolean __GLEW_EXT_memory_object = GL_FALSE; GLboolean __GLEW_EXT_memory_object_fd = GL_FALSE; GLboolean __GLEW_EXT_memory_object_win32 = GL_FALSE; +GLboolean __GLEW_EXT_mesh_shader = GL_FALSE; GLboolean __GLEW_EXT_misc_attribute = GL_FALSE; GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE; GLboolean __GLEW_EXT_multi_draw_indirect = GL_FALSE; @@ -3886,8 +3941,10 @@ GLboolean __GLEW_EXT_secondary_color = GL_FALSE; GLboolean __GLEW_EXT_semaphore = GL_FALSE; GLboolean __GLEW_EXT_semaphore_fd = GL_FALSE; GLboolean __GLEW_EXT_semaphore_win32 = GL_FALSE; +GLboolean __GLEW_EXT_separate_depth_stencil = GL_FALSE; GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE; GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE; +GLboolean __GLEW_EXT_shader_clock = GL_FALSE; GLboolean __GLEW_EXT_shader_framebuffer_fetch = GL_FALSE; GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent = GL_FALSE; GLboolean __GLEW_EXT_shader_group_vote = GL_FALSE; @@ -3899,7 +3956,10 @@ GLboolean __GLEW_EXT_shader_io_blocks = GL_FALSE; GLboolean __GLEW_EXT_shader_non_constant_global_initializers = GL_FALSE; GLboolean __GLEW_EXT_shader_pixel_local_storage = GL_FALSE; GLboolean __GLEW_EXT_shader_pixel_local_storage2 = GL_FALSE; +GLboolean __GLEW_EXT_shader_realtime_clock = GL_FALSE; +GLboolean __GLEW_EXT_shader_samples_identical = GL_FALSE; GLboolean __GLEW_EXT_shader_texture_lod = GL_FALSE; +GLboolean __GLEW_EXT_shader_texture_samples = GL_FALSE; GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE; GLboolean __GLEW_EXT_shadow_samplers = GL_FALSE; GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE; @@ -3955,6 +4015,7 @@ GLboolean __GLEW_EXT_texture_shadow_lod = GL_FALSE; GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE; GLboolean __GLEW_EXT_texture_snorm = GL_FALSE; GLboolean __GLEW_EXT_texture_storage = GL_FALSE; +GLboolean __GLEW_EXT_texture_storage_compression = GL_FALSE; GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE; GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV = GL_FALSE; GLboolean __GLEW_EXT_texture_view = GL_FALSE; @@ -3977,6 +4038,8 @@ GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE; GLboolean __GLEW_HP_image_transform = GL_FALSE; GLboolean __GLEW_HP_occlusion_test = GL_FALSE; GLboolean __GLEW_HP_texture_lighting = GL_FALSE; +GLboolean __GLEW_HUAWEI_program_binary = GL_FALSE; +GLboolean __GLEW_HUAWEI_shader_binary = GL_FALSE; GLboolean __GLEW_IBM_cull_vertex = GL_FALSE; GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE; GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE; @@ -3987,12 +4050,14 @@ GLboolean __GLEW_IMG_bindless_texture = GL_FALSE; GLboolean __GLEW_IMG_framebuffer_downsample = GL_FALSE; GLboolean __GLEW_IMG_multisampled_render_to_texture = GL_FALSE; GLboolean __GLEW_IMG_program_binary = GL_FALSE; +GLboolean __GLEW_IMG_pvric_end_to_end_signature = GL_FALSE; GLboolean __GLEW_IMG_read_format = GL_FALSE; GLboolean __GLEW_IMG_shader_binary = GL_FALSE; GLboolean __GLEW_IMG_texture_compression_pvrtc = GL_FALSE; GLboolean __GLEW_IMG_texture_compression_pvrtc2 = GL_FALSE; GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function = GL_FALSE; GLboolean __GLEW_IMG_texture_filter_cubic = GL_FALSE; +GLboolean __GLEW_IMG_tile_region_protection = GL_FALSE; GLboolean __GLEW_INGR_color_clamp = GL_FALSE; GLboolean __GLEW_INGR_interlace_read = GL_FALSE; GLboolean __GLEW_INTEL_blackhole_render = GL_FALSE; @@ -4018,11 +4083,15 @@ GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE; GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d = GL_FALSE; GLboolean __GLEW_KTX_buffer_region = GL_FALSE; GLboolean __GLEW_MESAX_texture_stack = GL_FALSE; +GLboolean __GLEW_MESA_bgra = GL_FALSE; +GLboolean __GLEW_MESA_framebuffer_flip_x = GL_FALSE; GLboolean __GLEW_MESA_framebuffer_flip_y = GL_FALSE; +GLboolean __GLEW_MESA_framebuffer_swap_xy = GL_FALSE; GLboolean __GLEW_MESA_pack_invert = GL_FALSE; GLboolean __GLEW_MESA_program_binary_formats = GL_FALSE; GLboolean __GLEW_MESA_resize_buffers = GL_FALSE; GLboolean __GLEW_MESA_shader_integer_functions = GL_FALSE; +GLboolean __GLEW_MESA_texture_const_bandwidth = GL_FALSE; GLboolean __GLEW_MESA_tile_raster_order = GL_FALSE; GLboolean __GLEW_MESA_window_pos = GL_FALSE; GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE; @@ -4100,6 +4169,7 @@ GLboolean __GLEW_NV_instanced_arrays = GL_FALSE; GLboolean __GLEW_NV_internalformat_sample_query = GL_FALSE; GLboolean __GLEW_NV_light_max_exponent = GL_FALSE; GLboolean __GLEW_NV_memory_attachment = GL_FALSE; +GLboolean __GLEW_NV_memory_object_sparse = GL_FALSE; GLboolean __GLEW_NV_mesh_shader = GL_FALSE; GLboolean __GLEW_NV_multisample_coverage = GL_FALSE; GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; @@ -4120,6 +4190,7 @@ GLboolean __GLEW_NV_point_sprite = GL_FALSE; GLboolean __GLEW_NV_polygon_mode = GL_FALSE; GLboolean __GLEW_NV_present_video = GL_FALSE; GLboolean __GLEW_NV_primitive_restart = GL_FALSE; +GLboolean __GLEW_NV_primitive_shading_rate = GL_FALSE; GLboolean __GLEW_NV_query_resource_tag = GL_FALSE; GLboolean __GLEW_NV_read_buffer = GL_FALSE; GLboolean __GLEW_NV_read_buffer_front = GL_FALSE; @@ -4169,8 +4240,10 @@ GLboolean __GLEW_NV_texture_rectangle_compressed = GL_FALSE; GLboolean __GLEW_NV_texture_shader = GL_FALSE; GLboolean __GLEW_NV_texture_shader2 = GL_FALSE; GLboolean __GLEW_NV_texture_shader3 = GL_FALSE; +GLboolean __GLEW_NV_timeline_semaphore = GL_FALSE; GLboolean __GLEW_NV_transform_feedback = GL_FALSE; GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE; +GLboolean __GLEW_NV_uniform_buffer_std430_layout = GL_FALSE; GLboolean __GLEW_NV_uniform_buffer_unified_memory = GL_FALSE; GLboolean __GLEW_NV_vdpau_interop = GL_FALSE; GLboolean __GLEW_NV_vdpau_interop2 = GL_FALSE; @@ -4264,14 +4337,22 @@ GLboolean __GLEW_QCOM_binning_control = GL_FALSE; GLboolean __GLEW_QCOM_driver_control = GL_FALSE; GLboolean __GLEW_QCOM_extended_get = GL_FALSE; GLboolean __GLEW_QCOM_extended_get2 = GL_FALSE; +GLboolean __GLEW_QCOM_frame_extrapolation = GL_FALSE; GLboolean __GLEW_QCOM_framebuffer_foveated = GL_FALSE; +GLboolean __GLEW_QCOM_motion_estimation = GL_FALSE; GLboolean __GLEW_QCOM_perfmon_global_mode = GL_FALSE; +GLboolean __GLEW_QCOM_render_sRGB_R8_RG8 = GL_FALSE; +GLboolean __GLEW_QCOM_render_shared_exponent = GL_FALSE; GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent = GL_FALSE; GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate = GL_FALSE; +GLboolean __GLEW_QCOM_shading_rate = GL_FALSE; GLboolean __GLEW_QCOM_texture_foveated = GL_FALSE; +GLboolean __GLEW_QCOM_texture_foveated2 = GL_FALSE; GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout = GL_FALSE; +GLboolean __GLEW_QCOM_texture_lod_bias = GL_FALSE; GLboolean __GLEW_QCOM_tiled_rendering = GL_FALSE; GLboolean __GLEW_QCOM_writeonly_rendering = GL_FALSE; +GLboolean __GLEW_QCOM_ycbcr_degamma = GL_FALSE; GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_enable = GL_FALSE; @@ -5173,6 +5254,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ARM_rgba8 "GL_ARM_rgba8", #endif +#ifdef GL_ARM_shader_core_properties + "GL_ARM_shader_core_properties", +#endif #ifdef GL_ARM_shader_framebuffer_fetch "GL_ARM_shader_framebuffer_fetch", #endif @@ -5266,6 +5350,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_EGL_image_storage "GL_EXT_EGL_image_storage", #endif +#ifdef GL_EXT_EGL_image_storage_compression + "GL_EXT_EGL_image_storage_compression", +#endif #ifdef GL_EXT_EGL_sync "GL_EXT_EGL_sync", #endif @@ -5413,9 +5500,21 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_fragment_lighting "GL_EXT_fragment_lighting", #endif +#ifdef GL_EXT_fragment_shading_rate + "GL_EXT_fragment_shading_rate", +#endif +#ifdef GL_EXT_fragment_shading_rate_attachment + "GL_EXT_fragment_shading_rate_attachment", +#endif +#ifdef GL_EXT_fragment_shading_rate_primitive + "GL_EXT_fragment_shading_rate_primitive", +#endif #ifdef GL_EXT_framebuffer_blit "GL_EXT_framebuffer_blit", #endif +#ifdef GL_EXT_framebuffer_blit_layers + "GL_EXT_framebuffer_blit_layers", +#endif #ifdef GL_EXT_framebuffer_multisample "GL_EXT_framebuffer_multisample", #endif @@ -5479,6 +5578,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_memory_object_win32 "GL_EXT_memory_object_win32", #endif +#ifdef GL_EXT_mesh_shader + "GL_EXT_mesh_shader", +#endif #ifdef GL_EXT_misc_attribute "GL_EXT_misc_attribute", #endif @@ -5599,12 +5701,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_semaphore_win32 "GL_EXT_semaphore_win32", #endif +#ifdef GL_EXT_separate_depth_stencil + "GL_EXT_separate_depth_stencil", +#endif #ifdef GL_EXT_separate_shader_objects "GL_EXT_separate_shader_objects", #endif #ifdef GL_EXT_separate_specular_color "GL_EXT_separate_specular_color", #endif +#ifdef GL_EXT_shader_clock + "GL_EXT_shader_clock", +#endif #ifdef GL_EXT_shader_framebuffer_fetch "GL_EXT_shader_framebuffer_fetch", #endif @@ -5638,9 +5746,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_shader_pixel_local_storage2 "GL_EXT_shader_pixel_local_storage2", #endif +#ifdef GL_EXT_shader_realtime_clock + "GL_EXT_shader_realtime_clock", +#endif +#ifdef GL_EXT_shader_samples_identical + "GL_EXT_shader_samples_identical", +#endif #ifdef GL_EXT_shader_texture_lod "GL_EXT_shader_texture_lod", #endif +#ifdef GL_EXT_shader_texture_samples + "GL_EXT_shader_texture_samples", +#endif #ifdef GL_EXT_shadow_funcs "GL_EXT_shadow_funcs", #endif @@ -5806,6 +5923,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_storage "GL_EXT_texture_storage", #endif +#ifdef GL_EXT_texture_storage_compression + "GL_EXT_texture_storage_compression", +#endif #ifdef GL_EXT_texture_swizzle "GL_EXT_texture_swizzle", #endif @@ -5872,6 +5992,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_HP_texture_lighting "GL_HP_texture_lighting", #endif +#ifdef GL_HUAWEI_program_binary + "GL_HUAWEI_program_binary", +#endif +#ifdef GL_HUAWEI_shader_binary + "GL_HUAWEI_shader_binary", +#endif #ifdef GL_IBM_cull_vertex "GL_IBM_cull_vertex", #endif @@ -5902,6 +6028,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_IMG_program_binary "GL_IMG_program_binary", #endif +#ifdef GL_IMG_pvric_end_to_end_signature + "GL_IMG_pvric_end_to_end_signature", +#endif #ifdef GL_IMG_read_format "GL_IMG_read_format", #endif @@ -5920,6 +6049,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_IMG_texture_filter_cubic "GL_IMG_texture_filter_cubic", #endif +#ifdef GL_IMG_tile_region_protection + "GL_IMG_tile_region_protection", +#endif #ifdef GL_INGR_color_clamp "GL_INGR_color_clamp", #endif @@ -5995,9 +6127,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_MESAX_texture_stack "GL_MESAX_texture_stack", #endif +#ifdef GL_MESA_bgra + "GL_MESA_bgra", +#endif +#ifdef GL_MESA_framebuffer_flip_x + "GL_MESA_framebuffer_flip_x", +#endif #ifdef GL_MESA_framebuffer_flip_y "GL_MESA_framebuffer_flip_y", #endif +#ifdef GL_MESA_framebuffer_swap_xy + "GL_MESA_framebuffer_swap_xy", +#endif #ifdef GL_MESA_pack_invert "GL_MESA_pack_invert", #endif @@ -6010,6 +6151,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_MESA_shader_integer_functions "GL_MESA_shader_integer_functions", #endif +#ifdef GL_MESA_texture_const_bandwidth + "GL_MESA_texture_const_bandwidth", +#endif #ifdef GL_MESA_tile_raster_order "GL_MESA_tile_raster_order", #endif @@ -6241,6 +6385,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_memory_attachment "GL_NV_memory_attachment", #endif +#ifdef GL_NV_memory_object_sparse + "GL_NV_memory_object_sparse", +#endif #ifdef GL_NV_mesh_shader "GL_NV_mesh_shader", #endif @@ -6301,6 +6448,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_primitive_restart "GL_NV_primitive_restart", #endif +#ifdef GL_NV_primitive_shading_rate + "GL_NV_primitive_shading_rate", +#endif #ifdef GL_NV_query_resource_tag "GL_NV_query_resource_tag", #endif @@ -6448,12 +6598,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_texture_shader3 "GL_NV_texture_shader3", #endif +#ifdef GL_NV_timeline_semaphore + "GL_NV_timeline_semaphore", +#endif #ifdef GL_NV_transform_feedback "GL_NV_transform_feedback", #endif #ifdef GL_NV_transform_feedback2 "GL_NV_transform_feedback2", #endif +#ifdef GL_NV_uniform_buffer_std430_layout + "GL_NV_uniform_buffer_std430_layout", +#endif #ifdef GL_NV_uniform_buffer_unified_memory "GL_NV_uniform_buffer_unified_memory", #endif @@ -6733,30 +6889,54 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_QCOM_extended_get2 "GL_QCOM_extended_get2", #endif +#ifdef GL_QCOM_frame_extrapolation + "GL_QCOM_frame_extrapolation", +#endif #ifdef GL_QCOM_framebuffer_foveated "GL_QCOM_framebuffer_foveated", #endif +#ifdef GL_QCOM_motion_estimation + "GL_QCOM_motion_estimation", +#endif #ifdef GL_QCOM_perfmon_global_mode "GL_QCOM_perfmon_global_mode", #endif +#ifdef GL_QCOM_render_sRGB_R8_RG8 + "GL_QCOM_render_sRGB_R8_RG8", +#endif +#ifdef GL_QCOM_render_shared_exponent + "GL_QCOM_render_shared_exponent", +#endif #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent "GL_QCOM_shader_framebuffer_fetch_noncoherent", #endif #ifdef GL_QCOM_shader_framebuffer_fetch_rate "GL_QCOM_shader_framebuffer_fetch_rate", #endif +#ifdef GL_QCOM_shading_rate + "GL_QCOM_shading_rate", +#endif #ifdef GL_QCOM_texture_foveated "GL_QCOM_texture_foveated", #endif +#ifdef GL_QCOM_texture_foveated2 + "GL_QCOM_texture_foveated2", +#endif #ifdef GL_QCOM_texture_foveated_subsampled_layout "GL_QCOM_texture_foveated_subsampled_layout", #endif +#ifdef GL_QCOM_texture_lod_bias + "GL_QCOM_texture_lod_bias", +#endif #ifdef GL_QCOM_tiled_rendering "GL_QCOM_tiled_rendering", #endif #ifdef GL_QCOM_writeonly_rendering "GL_QCOM_writeonly_rendering", #endif +#ifdef GL_QCOM_ycbcr_degamma + "GL_QCOM_ycbcr_degamma", +#endif #ifdef GL_REGAL_ES1_0_compatibility "GL_REGAL_ES1_0_compatibility", #endif @@ -7200,7 +7380,7 @@ static const char * _glewExtensionLookup[] = { /* Detected in the extension string or strings */ -static GLboolean _glewExtensionString[931]; +static GLboolean _glewExtensionString[964]; /* Detected via extension string or experimental mode */ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_3DFX_multisample @@ -7974,6 +8154,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ARM_rgba8 &__GLEW_ARM_rgba8, #endif +#ifdef GL_ARM_shader_core_properties + &__GLEW_ARM_shader_core_properties, +#endif #ifdef GL_ARM_shader_framebuffer_fetch &__GLEW_ARM_shader_framebuffer_fetch, #endif @@ -8067,6 +8250,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_EGL_image_storage &__GLEW_EXT_EGL_image_storage, #endif +#ifdef GL_EXT_EGL_image_storage_compression + &__GLEW_EXT_EGL_image_storage_compression, +#endif #ifdef GL_EXT_EGL_sync &__GLEW_EXT_EGL_sync, #endif @@ -8214,9 +8400,21 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_fragment_lighting &__GLEW_EXT_fragment_lighting, #endif +#ifdef GL_EXT_fragment_shading_rate + &__GLEW_EXT_fragment_shading_rate, +#endif +#ifdef GL_EXT_fragment_shading_rate_attachment + &__GLEW_EXT_fragment_shading_rate_attachment, +#endif +#ifdef GL_EXT_fragment_shading_rate_primitive + &__GLEW_EXT_fragment_shading_rate_primitive, +#endif #ifdef GL_EXT_framebuffer_blit &__GLEW_EXT_framebuffer_blit, #endif +#ifdef GL_EXT_framebuffer_blit_layers + &__GLEW_EXT_framebuffer_blit_layers, +#endif #ifdef GL_EXT_framebuffer_multisample &__GLEW_EXT_framebuffer_multisample, #endif @@ -8280,6 +8478,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_memory_object_win32 &__GLEW_EXT_memory_object_win32, #endif +#ifdef GL_EXT_mesh_shader + &__GLEW_EXT_mesh_shader, +#endif #ifdef GL_EXT_misc_attribute &__GLEW_EXT_misc_attribute, #endif @@ -8400,12 +8601,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_semaphore_win32 &__GLEW_EXT_semaphore_win32, #endif +#ifdef GL_EXT_separate_depth_stencil + &__GLEW_EXT_separate_depth_stencil, +#endif #ifdef GL_EXT_separate_shader_objects &__GLEW_EXT_separate_shader_objects, #endif #ifdef GL_EXT_separate_specular_color &__GLEW_EXT_separate_specular_color, #endif +#ifdef GL_EXT_shader_clock + &__GLEW_EXT_shader_clock, +#endif #ifdef GL_EXT_shader_framebuffer_fetch &__GLEW_EXT_shader_framebuffer_fetch, #endif @@ -8439,9 +8646,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_shader_pixel_local_storage2 &__GLEW_EXT_shader_pixel_local_storage2, #endif +#ifdef GL_EXT_shader_realtime_clock + &__GLEW_EXT_shader_realtime_clock, +#endif +#ifdef GL_EXT_shader_samples_identical + &__GLEW_EXT_shader_samples_identical, +#endif #ifdef GL_EXT_shader_texture_lod &__GLEW_EXT_shader_texture_lod, #endif +#ifdef GL_EXT_shader_texture_samples + &__GLEW_EXT_shader_texture_samples, +#endif #ifdef GL_EXT_shadow_funcs &__GLEW_EXT_shadow_funcs, #endif @@ -8607,6 +8823,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_storage &__GLEW_EXT_texture_storage, #endif +#ifdef GL_EXT_texture_storage_compression + &__GLEW_EXT_texture_storage_compression, +#endif #ifdef GL_EXT_texture_swizzle &__GLEW_EXT_texture_swizzle, #endif @@ -8673,6 +8892,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_HP_texture_lighting &__GLEW_HP_texture_lighting, #endif +#ifdef GL_HUAWEI_program_binary + &__GLEW_HUAWEI_program_binary, +#endif +#ifdef GL_HUAWEI_shader_binary + &__GLEW_HUAWEI_shader_binary, +#endif #ifdef GL_IBM_cull_vertex &__GLEW_IBM_cull_vertex, #endif @@ -8703,6 +8928,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_IMG_program_binary &__GLEW_IMG_program_binary, #endif +#ifdef GL_IMG_pvric_end_to_end_signature + &__GLEW_IMG_pvric_end_to_end_signature, +#endif #ifdef GL_IMG_read_format &__GLEW_IMG_read_format, #endif @@ -8721,6 +8949,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_IMG_texture_filter_cubic &__GLEW_IMG_texture_filter_cubic, #endif +#ifdef GL_IMG_tile_region_protection + &__GLEW_IMG_tile_region_protection, +#endif #ifdef GL_INGR_color_clamp &__GLEW_INGR_color_clamp, #endif @@ -8796,9 +9027,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_MESAX_texture_stack &__GLEW_MESAX_texture_stack, #endif +#ifdef GL_MESA_bgra + &__GLEW_MESA_bgra, +#endif +#ifdef GL_MESA_framebuffer_flip_x + &__GLEW_MESA_framebuffer_flip_x, +#endif #ifdef GL_MESA_framebuffer_flip_y &__GLEW_MESA_framebuffer_flip_y, #endif +#ifdef GL_MESA_framebuffer_swap_xy + &__GLEW_MESA_framebuffer_swap_xy, +#endif #ifdef GL_MESA_pack_invert &__GLEW_MESA_pack_invert, #endif @@ -8811,6 +9051,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_MESA_shader_integer_functions &__GLEW_MESA_shader_integer_functions, #endif +#ifdef GL_MESA_texture_const_bandwidth + &__GLEW_MESA_texture_const_bandwidth, +#endif #ifdef GL_MESA_tile_raster_order &__GLEW_MESA_tile_raster_order, #endif @@ -9042,6 +9285,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_memory_attachment &__GLEW_NV_memory_attachment, #endif +#ifdef GL_NV_memory_object_sparse + &__GLEW_NV_memory_object_sparse, +#endif #ifdef GL_NV_mesh_shader &__GLEW_NV_mesh_shader, #endif @@ -9102,6 +9348,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_primitive_restart &__GLEW_NV_primitive_restart, #endif +#ifdef GL_NV_primitive_shading_rate + &__GLEW_NV_primitive_shading_rate, +#endif #ifdef GL_NV_query_resource_tag &__GLEW_NV_query_resource_tag, #endif @@ -9249,12 +9498,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_texture_shader3 &__GLEW_NV_texture_shader3, #endif +#ifdef GL_NV_timeline_semaphore + &__GLEW_NV_timeline_semaphore, +#endif #ifdef GL_NV_transform_feedback &__GLEW_NV_transform_feedback, #endif #ifdef GL_NV_transform_feedback2 &__GLEW_NV_transform_feedback2, #endif +#ifdef GL_NV_uniform_buffer_std430_layout + &__GLEW_NV_uniform_buffer_std430_layout, +#endif #ifdef GL_NV_uniform_buffer_unified_memory &__GLEW_NV_uniform_buffer_unified_memory, #endif @@ -9534,30 +9789,54 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_QCOM_extended_get2 &__GLEW_QCOM_extended_get2, #endif +#ifdef GL_QCOM_frame_extrapolation + &__GLEW_QCOM_frame_extrapolation, +#endif #ifdef GL_QCOM_framebuffer_foveated &__GLEW_QCOM_framebuffer_foveated, #endif +#ifdef GL_QCOM_motion_estimation + &__GLEW_QCOM_motion_estimation, +#endif #ifdef GL_QCOM_perfmon_global_mode &__GLEW_QCOM_perfmon_global_mode, #endif +#ifdef GL_QCOM_render_sRGB_R8_RG8 + &__GLEW_QCOM_render_sRGB_R8_RG8, +#endif +#ifdef GL_QCOM_render_shared_exponent + &__GLEW_QCOM_render_shared_exponent, +#endif #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent &__GLEW_QCOM_shader_framebuffer_fetch_noncoherent, #endif #ifdef GL_QCOM_shader_framebuffer_fetch_rate &__GLEW_QCOM_shader_framebuffer_fetch_rate, #endif +#ifdef GL_QCOM_shading_rate + &__GLEW_QCOM_shading_rate, +#endif #ifdef GL_QCOM_texture_foveated &__GLEW_QCOM_texture_foveated, #endif +#ifdef GL_QCOM_texture_foveated2 + &__GLEW_QCOM_texture_foveated2, +#endif #ifdef GL_QCOM_texture_foveated_subsampled_layout &__GLEW_QCOM_texture_foveated_subsampled_layout, #endif +#ifdef GL_QCOM_texture_lod_bias + &__GLEW_QCOM_texture_lod_bias, +#endif #ifdef GL_QCOM_tiled_rendering &__GLEW_QCOM_tiled_rendering, #endif #ifdef GL_QCOM_writeonly_rendering &__GLEW_QCOM_writeonly_rendering, #endif +#ifdef GL_QCOM_ycbcr_degamma + &__GLEW_QCOM_ycbcr_degamma, +#endif #ifdef GL_REGAL_ES1_0_compatibility &__GLEW_REGAL_ES1_0_compatibility, #endif @@ -9999,404 +10278,415 @@ static GLboolean* _glewExtensionEnabled[] = { NULL }; -static GLboolean _glewInit_GL_VERSION_1_2 (); -static GLboolean _glewInit_GL_VERSION_1_3 (); -static GLboolean _glewInit_GL_VERSION_1_4 (); -static GLboolean _glewInit_GL_VERSION_1_5 (); -static GLboolean _glewInit_GL_VERSION_2_0 (); -static GLboolean _glewInit_GL_VERSION_2_1 (); -static GLboolean _glewInit_GL_VERSION_3_0 (); -static GLboolean _glewInit_GL_VERSION_3_1 (); -static GLboolean _glewInit_GL_VERSION_3_2 (); -static GLboolean _glewInit_GL_VERSION_3_3 (); -static GLboolean _glewInit_GL_VERSION_4_0 (); -static GLboolean _glewInit_GL_VERSION_4_5 (); -static GLboolean _glewInit_GL_VERSION_4_6 (); -static GLboolean _glewInit_GL_3DFX_tbuffer (); -static GLboolean _glewInit_GL_AMD_debug_output (); -static GLboolean _glewInit_GL_AMD_draw_buffers_blend (); -static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (); -static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (); -static GLboolean _glewInit_GL_AMD_interleaved_elements (); -static GLboolean _glewInit_GL_AMD_multi_draw_indirect (); -static GLboolean _glewInit_GL_AMD_name_gen_delete (); -static GLboolean _glewInit_GL_AMD_occlusion_query_event (); -static GLboolean _glewInit_GL_AMD_performance_monitor (); -static GLboolean _glewInit_GL_AMD_sample_positions (); -static GLboolean _glewInit_GL_AMD_sparse_texture (); -static GLboolean _glewInit_GL_AMD_stencil_operation_extended (); -static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (); -static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (); -static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (); -static GLboolean _glewInit_GL_ANGLE_instanced_arrays (); -static GLboolean _glewInit_GL_ANGLE_timer_query (); -static GLboolean _glewInit_GL_ANGLE_translated_shader_source (); -static GLboolean _glewInit_GL_APPLE_copy_texture_levels (); -static GLboolean _glewInit_GL_APPLE_element_array (); -static GLboolean _glewInit_GL_APPLE_fence (); -static GLboolean _glewInit_GL_APPLE_flush_buffer_range (); -static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (); -static GLboolean _glewInit_GL_APPLE_object_purgeable (); -static GLboolean _glewInit_GL_APPLE_sync (); -static GLboolean _glewInit_GL_APPLE_texture_range (); -static GLboolean _glewInit_GL_APPLE_vertex_array_object (); -static GLboolean _glewInit_GL_APPLE_vertex_array_range (); -static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (); -static GLboolean _glewInit_GL_ARB_ES2_compatibility (); -static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (); -static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (); -static GLboolean _glewInit_GL_ARB_base_instance (); -static GLboolean _glewInit_GL_ARB_bindless_texture (); -static GLboolean _glewInit_GL_ARB_blend_func_extended (); -static GLboolean _glewInit_GL_ARB_buffer_storage (); -static GLboolean _glewInit_GL_ARB_cl_event (); -static GLboolean _glewInit_GL_ARB_clear_buffer_object (); -static GLboolean _glewInit_GL_ARB_clear_texture (); -static GLboolean _glewInit_GL_ARB_clip_control (); -static GLboolean _glewInit_GL_ARB_color_buffer_float (); -static GLboolean _glewInit_GL_ARB_compute_shader (); -static GLboolean _glewInit_GL_ARB_compute_variable_group_size (); -static GLboolean _glewInit_GL_ARB_copy_buffer (); -static GLboolean _glewInit_GL_ARB_copy_image (); -static GLboolean _glewInit_GL_ARB_debug_output (); -static GLboolean _glewInit_GL_ARB_direct_state_access (); -static GLboolean _glewInit_GL_ARB_draw_buffers (); -static GLboolean _glewInit_GL_ARB_draw_buffers_blend (); -static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (); -static GLboolean _glewInit_GL_ARB_draw_indirect (); -static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (); -static GLboolean _glewInit_GL_ARB_framebuffer_object (); -static GLboolean _glewInit_GL_ARB_geometry_shader4 (); -static GLboolean _glewInit_GL_ARB_get_program_binary (); -static GLboolean _glewInit_GL_ARB_get_texture_sub_image (); -static GLboolean _glewInit_GL_ARB_gl_spirv (); -static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (); -static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (); -static GLboolean _glewInit_GL_ARB_imaging (); -static GLboolean _glewInit_GL_ARB_indirect_parameters (); -static GLboolean _glewInit_GL_ARB_instanced_arrays (); -static GLboolean _glewInit_GL_ARB_internalformat_query (); -static GLboolean _glewInit_GL_ARB_internalformat_query2 (); -static GLboolean _glewInit_GL_ARB_invalidate_subdata (); -static GLboolean _glewInit_GL_ARB_map_buffer_range (); -static GLboolean _glewInit_GL_ARB_matrix_palette (); -static GLboolean _glewInit_GL_ARB_multi_bind (); -static GLboolean _glewInit_GL_ARB_multi_draw_indirect (); -static GLboolean _glewInit_GL_ARB_multisample (); -static GLboolean _glewInit_GL_ARB_multitexture (); -static GLboolean _glewInit_GL_ARB_occlusion_query (); -static GLboolean _glewInit_GL_ARB_parallel_shader_compile (); -static GLboolean _glewInit_GL_ARB_point_parameters (); -static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (); -static GLboolean _glewInit_GL_ARB_program_interface_query (); -static GLboolean _glewInit_GL_ARB_provoking_vertex (); -static GLboolean _glewInit_GL_ARB_robustness (); -static GLboolean _glewInit_GL_ARB_sample_locations (); -static GLboolean _glewInit_GL_ARB_sample_shading (); -static GLboolean _glewInit_GL_ARB_sampler_objects (); -static GLboolean _glewInit_GL_ARB_separate_shader_objects (); -static GLboolean _glewInit_GL_ARB_shader_atomic_counters (); -static GLboolean _glewInit_GL_ARB_shader_image_load_store (); -static GLboolean _glewInit_GL_ARB_shader_objects (); -static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (); -static GLboolean _glewInit_GL_ARB_shader_subroutine (); -static GLboolean _glewInit_GL_ARB_shading_language_include (); -static GLboolean _glewInit_GL_ARB_sparse_buffer (); -static GLboolean _glewInit_GL_ARB_sparse_texture (); -static GLboolean _glewInit_GL_ARB_sync (); -static GLboolean _glewInit_GL_ARB_tessellation_shader (); -static GLboolean _glewInit_GL_ARB_texture_barrier (); -static GLboolean _glewInit_GL_ARB_texture_buffer_object (); -static GLboolean _glewInit_GL_ARB_texture_buffer_range (); -static GLboolean _glewInit_GL_ARB_texture_compression (); -static GLboolean _glewInit_GL_ARB_texture_multisample (); -static GLboolean _glewInit_GL_ARB_texture_storage (); -static GLboolean _glewInit_GL_ARB_texture_storage_multisample (); -static GLboolean _glewInit_GL_ARB_texture_view (); -static GLboolean _glewInit_GL_ARB_timer_query (); -static GLboolean _glewInit_GL_ARB_transform_feedback2 (); -static GLboolean _glewInit_GL_ARB_transform_feedback3 (); -static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (); -static GLboolean _glewInit_GL_ARB_transpose_matrix (); -static GLboolean _glewInit_GL_ARB_uniform_buffer_object (); -static GLboolean _glewInit_GL_ARB_vertex_array_object (); -static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (); -static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (); -static GLboolean _glewInit_GL_ARB_vertex_blend (); -static GLboolean _glewInit_GL_ARB_vertex_buffer_object (); -static GLboolean _glewInit_GL_ARB_vertex_program (); -static GLboolean _glewInit_GL_ARB_vertex_shader (); -static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (); -static GLboolean _glewInit_GL_ARB_viewport_array (); -static GLboolean _glewInit_GL_ARB_window_pos (); -static GLboolean _glewInit_GL_ATI_draw_buffers (); -static GLboolean _glewInit_GL_ATI_element_array (); -static GLboolean _glewInit_GL_ATI_envmap_bumpmap (); -static GLboolean _glewInit_GL_ATI_fragment_shader (); -static GLboolean _glewInit_GL_ATI_map_object_buffer (); -static GLboolean _glewInit_GL_ATI_pn_triangles (); -static GLboolean _glewInit_GL_ATI_separate_stencil (); -static GLboolean _glewInit_GL_ATI_vertex_array_object (); -static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (); -static GLboolean _glewInit_GL_ATI_vertex_streams (); -static GLboolean _glewInit_GL_EXT_EGL_image_storage (); -static GLboolean _glewInit_GL_EXT_base_instance (); -static GLboolean _glewInit_GL_EXT_bindable_uniform (); -static GLboolean _glewInit_GL_EXT_blend_color (); -static GLboolean _glewInit_GL_EXT_blend_equation_separate (); -static GLboolean _glewInit_GL_EXT_blend_func_extended (); -static GLboolean _glewInit_GL_EXT_blend_func_separate (); -static GLboolean _glewInit_GL_EXT_blend_minmax (); -static GLboolean _glewInit_GL_EXT_buffer_storage (); -static GLboolean _glewInit_GL_EXT_clear_texture (); -static GLboolean _glewInit_GL_EXT_clip_control (); -static GLboolean _glewInit_GL_EXT_color_subtable (); -static GLboolean _glewInit_GL_EXT_compiled_vertex_array (); -static GLboolean _glewInit_GL_EXT_convolution (); -static GLboolean _glewInit_GL_EXT_coordinate_frame (); -static GLboolean _glewInit_GL_EXT_copy_image (); -static GLboolean _glewInit_GL_EXT_copy_texture (); -static GLboolean _glewInit_GL_EXT_cull_vertex (); -static GLboolean _glewInit_GL_EXT_debug_label (); -static GLboolean _glewInit_GL_EXT_debug_marker (); -static GLboolean _glewInit_GL_EXT_depth_bounds_test (); -static GLboolean _glewInit_GL_EXT_direct_state_access (); -static GLboolean _glewInit_GL_EXT_discard_framebuffer (); -static GLboolean _glewInit_GL_EXT_disjoint_timer_query (); -static GLboolean _glewInit_GL_EXT_draw_buffers (); -static GLboolean _glewInit_GL_EXT_draw_buffers2 (); -static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (); -static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (); -static GLboolean _glewInit_GL_EXT_draw_instanced (); -static GLboolean _glewInit_GL_EXT_draw_range_elements (); -static GLboolean _glewInit_GL_EXT_draw_transform_feedback (); -static GLboolean _glewInit_GL_EXT_external_buffer (); -static GLboolean _glewInit_GL_EXT_fog_coord (); -static GLboolean _glewInit_GL_EXT_fragment_lighting (); -static GLboolean _glewInit_GL_EXT_framebuffer_blit (); -static GLboolean _glewInit_GL_EXT_framebuffer_multisample (); -static GLboolean _glewInit_GL_EXT_framebuffer_object (); -static GLboolean _glewInit_GL_EXT_geometry_shader4 (); -static GLboolean _glewInit_GL_EXT_gpu_program_parameters (); -static GLboolean _glewInit_GL_EXT_gpu_shader4 (); -static GLboolean _glewInit_GL_EXT_histogram (); -static GLboolean _glewInit_GL_EXT_index_func (); -static GLboolean _glewInit_GL_EXT_index_material (); -static GLboolean _glewInit_GL_EXT_instanced_arrays (); -static GLboolean _glewInit_GL_EXT_light_texture (); -static GLboolean _glewInit_GL_EXT_map_buffer_range (); -static GLboolean _glewInit_GL_EXT_memory_object (); -static GLboolean _glewInit_GL_EXT_memory_object_fd (); -static GLboolean _glewInit_GL_EXT_memory_object_win32 (); -static GLboolean _glewInit_GL_EXT_multi_draw_arrays (); -static GLboolean _glewInit_GL_EXT_multi_draw_indirect (); -static GLboolean _glewInit_GL_EXT_multisample (); -static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (); -static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (); -static GLboolean _glewInit_GL_EXT_paletted_texture (); -static GLboolean _glewInit_GL_EXT_pixel_transform (); -static GLboolean _glewInit_GL_EXT_point_parameters (); -static GLboolean _glewInit_GL_EXT_polygon_offset (); -static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (); -static GLboolean _glewInit_GL_EXT_primitive_bounding_box (); -static GLboolean _glewInit_GL_EXT_provoking_vertex (); -static GLboolean _glewInit_GL_EXT_raster_multisample (); -static GLboolean _glewInit_GL_EXT_robustness (); -static GLboolean _glewInit_GL_EXT_scene_marker (); -static GLboolean _glewInit_GL_EXT_secondary_color (); -static GLboolean _glewInit_GL_EXT_semaphore (); -static GLboolean _glewInit_GL_EXT_semaphore_fd (); -static GLboolean _glewInit_GL_EXT_semaphore_win32 (); -static GLboolean _glewInit_GL_EXT_separate_shader_objects (); -static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (); -static GLboolean _glewInit_GL_EXT_shader_image_load_store (); -static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (); -static GLboolean _glewInit_GL_EXT_sparse_texture (); -static GLboolean _glewInit_GL_EXT_stencil_two_side (); -static GLboolean _glewInit_GL_EXT_subtexture (); -static GLboolean _glewInit_GL_EXT_tessellation_point_size (); -static GLboolean _glewInit_GL_EXT_texture3D (); -static GLboolean _glewInit_GL_EXT_texture_array (); -static GLboolean _glewInit_GL_EXT_texture_border_clamp (); -static GLboolean _glewInit_GL_EXT_texture_buffer_object (); -static GLboolean _glewInit_GL_EXT_texture_integer (); -static GLboolean _glewInit_GL_EXT_texture_object (); -static GLboolean _glewInit_GL_EXT_texture_perturb_normal (); -static GLboolean _glewInit_GL_EXT_texture_storage (); -static GLboolean _glewInit_GL_EXT_texture_view (); -static GLboolean _glewInit_GL_EXT_timer_query (); -static GLboolean _glewInit_GL_EXT_transform_feedback (); -static GLboolean _glewInit_GL_EXT_vertex_array (); -static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (); -static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (); -static GLboolean _glewInit_GL_EXT_vertex_shader (); -static GLboolean _glewInit_GL_EXT_vertex_weighting (); -static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (); -static GLboolean _glewInit_GL_EXT_window_rectangles (); -static GLboolean _glewInit_GL_EXT_x11_sync_object (); -static GLboolean _glewInit_GL_GREMEDY_frame_terminator (); -static GLboolean _glewInit_GL_GREMEDY_string_marker (); -static GLboolean _glewInit_GL_HP_image_transform (); -static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (); -static GLboolean _glewInit_GL_IBM_vertex_array_lists (); -static GLboolean _glewInit_GL_IMG_bindless_texture (); -static GLboolean _glewInit_GL_IMG_framebuffer_downsample (); -static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (); -static GLboolean _glewInit_GL_INTEL_map_texture (); -static GLboolean _glewInit_GL_INTEL_parallel_arrays (); -static GLboolean _glewInit_GL_INTEL_performance_query (); -static GLboolean _glewInit_GL_INTEL_texture_scissor (); -static GLboolean _glewInit_GL_KHR_blend_equation_advanced (); -static GLboolean _glewInit_GL_KHR_debug (); -static GLboolean _glewInit_GL_KHR_parallel_shader_compile (); -static GLboolean _glewInit_GL_KHR_robustness (); -static GLboolean _glewInit_GL_KTX_buffer_region (); -static GLboolean _glewInit_GL_MESA_framebuffer_flip_y (); -static GLboolean _glewInit_GL_MESA_resize_buffers (); -static GLboolean _glewInit_GL_MESA_window_pos (); -static GLboolean _glewInit_GL_NVX_conditional_render (); -static GLboolean _glewInit_GL_NVX_gpu_multicast2 (); -static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (); -static GLboolean _glewInit_GL_NVX_progress_fence (); -static GLboolean _glewInit_GL_NV_3dvision_settings (); -static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control (); -static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (); -static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (); -static GLboolean _glewInit_GL_NV_bindless_texture (); -static GLboolean _glewInit_GL_NV_blend_equation_advanced (); -static GLboolean _glewInit_GL_NV_clip_space_w_scaling (); -static GLboolean _glewInit_GL_NV_command_list (); -static GLboolean _glewInit_GL_NV_conditional_render (); -static GLboolean _glewInit_GL_NV_conservative_raster (); -static GLboolean _glewInit_GL_NV_conservative_raster_dilate (); -static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (); -static GLboolean _glewInit_GL_NV_copy_buffer (); -static GLboolean _glewInit_GL_NV_copy_image (); -static GLboolean _glewInit_GL_NV_depth_buffer_float (); -static GLboolean _glewInit_GL_NV_draw_buffers (); -static GLboolean _glewInit_GL_NV_draw_instanced (); -static GLboolean _glewInit_GL_NV_draw_texture (); -static GLboolean _glewInit_GL_NV_draw_vulkan_image (); -static GLboolean _glewInit_GL_NV_evaluators (); -static GLboolean _glewInit_GL_NV_explicit_multisample (); -static GLboolean _glewInit_GL_NV_fence (); -static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (); -static GLboolean _glewInit_GL_NV_fragment_program (); -static GLboolean _glewInit_GL_NV_framebuffer_blit (); -static GLboolean _glewInit_GL_NV_framebuffer_multisample (); -static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (); -static GLboolean _glewInit_GL_NV_geometry_program4 (); -static GLboolean _glewInit_GL_NV_gpu_multicast (); -static GLboolean _glewInit_GL_NV_gpu_program4 (); -static GLboolean _glewInit_GL_NV_gpu_shader5 (); -static GLboolean _glewInit_GL_NV_half_float (); -static GLboolean _glewInit_GL_NV_instanced_arrays (); -static GLboolean _glewInit_GL_NV_internalformat_sample_query (); -static GLboolean _glewInit_GL_NV_memory_attachment (); -static GLboolean _glewInit_GL_NV_mesh_shader (); -static GLboolean _glewInit_GL_NV_non_square_matrices (); -static GLboolean _glewInit_GL_NV_occlusion_query (); -static GLboolean _glewInit_GL_NV_parameter_buffer_object (); -static GLboolean _glewInit_GL_NV_path_rendering (); -static GLboolean _glewInit_GL_NV_pixel_data_range (); -static GLboolean _glewInit_GL_NV_point_sprite (); -static GLboolean _glewInit_GL_NV_polygon_mode (); -static GLboolean _glewInit_GL_NV_present_video (); -static GLboolean _glewInit_GL_NV_primitive_restart (); -static GLboolean _glewInit_GL_NV_read_buffer (); -static GLboolean _glewInit_GL_NV_register_combiners (); -static GLboolean _glewInit_GL_NV_register_combiners2 (); -static GLboolean _glewInit_GL_NV_sample_locations (); -static GLboolean _glewInit_GL_NV_scissor_exclusive (); -static GLboolean _glewInit_GL_NV_shader_buffer_load (); -static GLboolean _glewInit_GL_NV_shading_rate_image (); -static GLboolean _glewInit_GL_NV_texture_array (); -static GLboolean _glewInit_GL_NV_texture_barrier (); -static GLboolean _glewInit_GL_NV_texture_multisample (); -static GLboolean _glewInit_GL_NV_transform_feedback (); -static GLboolean _glewInit_GL_NV_transform_feedback2 (); -static GLboolean _glewInit_GL_NV_vdpau_interop (); -static GLboolean _glewInit_GL_NV_vdpau_interop2 (); -static GLboolean _glewInit_GL_NV_vertex_array_range (); -static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (); -static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (); -static GLboolean _glewInit_GL_NV_vertex_program (); -static GLboolean _glewInit_GL_NV_video_capture (); -static GLboolean _glewInit_GL_NV_viewport_array (); -static GLboolean _glewInit_GL_NV_viewport_swizzle (); -static GLboolean _glewInit_GL_OES_EGL_image (); -static GLboolean _glewInit_GL_OES_blend_equation_separate (); -static GLboolean _glewInit_GL_OES_blend_func_separate (); -static GLboolean _glewInit_GL_OES_blend_subtract (); -static GLboolean _glewInit_GL_OES_copy_image (); -static GLboolean _glewInit_GL_OES_draw_buffers_indexed (); -static GLboolean _glewInit_GL_OES_framebuffer_object (); -static GLboolean _glewInit_GL_OES_get_program_binary (); -static GLboolean _glewInit_GL_OES_mapbuffer (); -static GLboolean _glewInit_GL_OES_matrix_palette (); -static GLboolean _glewInit_GL_OES_sample_shading (); -static GLboolean _glewInit_GL_OES_single_precision (); -static GLboolean _glewInit_GL_OES_texture_3D (); -static GLboolean _glewInit_GL_OES_texture_border_clamp (); -static GLboolean _glewInit_GL_OES_texture_buffer (); -static GLboolean _glewInit_GL_OES_texture_cube_map (); -static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (); -static GLboolean _glewInit_GL_OES_texture_view (); -static GLboolean _glewInit_GL_OES_vertex_array_object (); -static GLboolean _glewInit_GL_OVR_multiview (); -static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (); -static GLboolean _glewInit_GL_QCOM_alpha_test (); -static GLboolean _glewInit_GL_QCOM_driver_control (); -static GLboolean _glewInit_GL_QCOM_extended_get (); -static GLboolean _glewInit_GL_QCOM_extended_get2 (); -static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (); -static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (); -static GLboolean _glewInit_GL_QCOM_texture_foveated (); -static GLboolean _glewInit_GL_QCOM_tiled_rendering (); -static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (); -static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (); -static GLboolean _glewInit_GL_REGAL_error_string (); -static GLboolean _glewInit_GL_REGAL_extension_query (); -static GLboolean _glewInit_GL_REGAL_log (); -static GLboolean _glewInit_GL_REGAL_proc_address (); -static GLboolean _glewInit_GL_SGIS_detail_texture (); -static GLboolean _glewInit_GL_SGIS_fog_function (); -static GLboolean _glewInit_GL_SGIS_multisample (); -static GLboolean _glewInit_GL_SGIS_multitexture (); -static GLboolean _glewInit_GL_SGIS_shared_multisample (); -static GLboolean _glewInit_GL_SGIS_sharpen_texture (); -static GLboolean _glewInit_GL_SGIS_texture4D (); -static GLboolean _glewInit_GL_SGIS_texture_filter4 (); -static GLboolean _glewInit_GL_SGIX_async (); -static GLboolean _glewInit_GL_SGIX_datapipe (); -static GLboolean _glewInit_GL_SGIX_flush_raster (); -static GLboolean _glewInit_GL_SGIX_fog_layers (); -static GLboolean _glewInit_GL_SGIX_fog_texture (); -static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (); -static GLboolean _glewInit_GL_SGIX_framezoom (); -static GLboolean _glewInit_GL_SGIX_igloo_interface (); -static GLboolean _glewInit_GL_SGIX_mpeg1 (); -static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (); -static GLboolean _glewInit_GL_SGIX_pixel_texture (); -static GLboolean _glewInit_GL_SGIX_polynomial_ffd (); -static GLboolean _glewInit_GL_SGIX_quad_mesh (); -static GLboolean _glewInit_GL_SGIX_reference_plane (); -static GLboolean _glewInit_GL_SGIX_sprite (); -static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (); -static GLboolean _glewInit_GL_SGIX_vector_ops (); -static GLboolean _glewInit_GL_SGIX_vertex_array_object (); -static GLboolean _glewInit_GL_SGI_color_table (); -static GLboolean _glewInit_GL_SGI_fft (); -static GLboolean _glewInit_GL_SUNX_constant_data (); -static GLboolean _glewInit_GL_SUN_global_alpha (); -static GLboolean _glewInit_GL_SUN_read_video_pixels (); -static GLboolean _glewInit_GL_SUN_triangle_list (); -static GLboolean _glewInit_GL_SUN_vertex (); -static GLboolean _glewInit_GL_WIN_swap_hint (); +static GLboolean _glewInit_GL_VERSION_1_2 (void); +static GLboolean _glewInit_GL_VERSION_1_3 (void); +static GLboolean _glewInit_GL_VERSION_1_4 (void); +static GLboolean _glewInit_GL_VERSION_1_5 (void); +static GLboolean _glewInit_GL_VERSION_2_0 (void); +static GLboolean _glewInit_GL_VERSION_2_1 (void); +static GLboolean _glewInit_GL_VERSION_3_0 (void); +static GLboolean _glewInit_GL_VERSION_3_1 (void); +static GLboolean _glewInit_GL_VERSION_3_2 (void); +static GLboolean _glewInit_GL_VERSION_3_3 (void); +static GLboolean _glewInit_GL_VERSION_4_0 (void); +static GLboolean _glewInit_GL_VERSION_4_5 (void); +static GLboolean _glewInit_GL_VERSION_4_6 (void); +static GLboolean _glewInit_GL_3DFX_tbuffer (void); +static GLboolean _glewInit_GL_AMD_debug_output (void); +static GLboolean _glewInit_GL_AMD_draw_buffers_blend (void); +static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (void); +static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (void); +static GLboolean _glewInit_GL_AMD_interleaved_elements (void); +static GLboolean _glewInit_GL_AMD_multi_draw_indirect (void); +static GLboolean _glewInit_GL_AMD_name_gen_delete (void); +static GLboolean _glewInit_GL_AMD_occlusion_query_event (void); +static GLboolean _glewInit_GL_AMD_performance_monitor (void); +static GLboolean _glewInit_GL_AMD_sample_positions (void); +static GLboolean _glewInit_GL_AMD_sparse_texture (void); +static GLboolean _glewInit_GL_AMD_stencil_operation_extended (void); +static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (void); +static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (void); +static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (void); +static GLboolean _glewInit_GL_ANGLE_instanced_arrays (void); +static GLboolean _glewInit_GL_ANGLE_timer_query (void); +static GLboolean _glewInit_GL_ANGLE_translated_shader_source (void); +static GLboolean _glewInit_GL_APPLE_copy_texture_levels (void); +static GLboolean _glewInit_GL_APPLE_element_array (void); +static GLboolean _glewInit_GL_APPLE_fence (void); +static GLboolean _glewInit_GL_APPLE_flush_buffer_range (void); +static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (void); +static GLboolean _glewInit_GL_APPLE_object_purgeable (void); +static GLboolean _glewInit_GL_APPLE_sync (void); +static GLboolean _glewInit_GL_APPLE_texture_range (void); +static GLboolean _glewInit_GL_APPLE_vertex_array_object (void); +static GLboolean _glewInit_GL_APPLE_vertex_array_range (void); +static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (void); +static GLboolean _glewInit_GL_ARB_ES2_compatibility (void); +static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (void); +static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (void); +static GLboolean _glewInit_GL_ARB_base_instance (void); +static GLboolean _glewInit_GL_ARB_bindless_texture (void); +static GLboolean _glewInit_GL_ARB_blend_func_extended (void); +static GLboolean _glewInit_GL_ARB_buffer_storage (void); +static GLboolean _glewInit_GL_ARB_cl_event (void); +static GLboolean _glewInit_GL_ARB_clear_buffer_object (void); +static GLboolean _glewInit_GL_ARB_clear_texture (void); +static GLboolean _glewInit_GL_ARB_clip_control (void); +static GLboolean _glewInit_GL_ARB_color_buffer_float (void); +static GLboolean _glewInit_GL_ARB_compute_shader (void); +static GLboolean _glewInit_GL_ARB_compute_variable_group_size (void); +static GLboolean _glewInit_GL_ARB_copy_buffer (void); +static GLboolean _glewInit_GL_ARB_copy_image (void); +static GLboolean _glewInit_GL_ARB_debug_output (void); +static GLboolean _glewInit_GL_ARB_direct_state_access (void); +static GLboolean _glewInit_GL_ARB_draw_buffers (void); +static GLboolean _glewInit_GL_ARB_draw_buffers_blend (void); +static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (void); +static GLboolean _glewInit_GL_ARB_draw_indirect (void); +static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (void); +static GLboolean _glewInit_GL_ARB_framebuffer_object (void); +static GLboolean _glewInit_GL_ARB_geometry_shader4 (void); +static GLboolean _glewInit_GL_ARB_get_program_binary (void); +static GLboolean _glewInit_GL_ARB_get_texture_sub_image (void); +static GLboolean _glewInit_GL_ARB_gl_spirv (void); +static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (void); +static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (void); +static GLboolean _glewInit_GL_ARB_imaging (void); +static GLboolean _glewInit_GL_ARB_indirect_parameters (void); +static GLboolean _glewInit_GL_ARB_instanced_arrays (void); +static GLboolean _glewInit_GL_ARB_internalformat_query (void); +static GLboolean _glewInit_GL_ARB_internalformat_query2 (void); +static GLboolean _glewInit_GL_ARB_invalidate_subdata (void); +static GLboolean _glewInit_GL_ARB_map_buffer_range (void); +static GLboolean _glewInit_GL_ARB_matrix_palette (void); +static GLboolean _glewInit_GL_ARB_multi_bind (void); +static GLboolean _glewInit_GL_ARB_multi_draw_indirect (void); +static GLboolean _glewInit_GL_ARB_multisample (void); +static GLboolean _glewInit_GL_ARB_multitexture (void); +static GLboolean _glewInit_GL_ARB_occlusion_query (void); +static GLboolean _glewInit_GL_ARB_parallel_shader_compile (void); +static GLboolean _glewInit_GL_ARB_point_parameters (void); +static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (void); +static GLboolean _glewInit_GL_ARB_program_interface_query (void); +static GLboolean _glewInit_GL_ARB_provoking_vertex (void); +static GLboolean _glewInit_GL_ARB_robustness (void); +static GLboolean _glewInit_GL_ARB_sample_locations (void); +static GLboolean _glewInit_GL_ARB_sample_shading (void); +static GLboolean _glewInit_GL_ARB_sampler_objects (void); +static GLboolean _glewInit_GL_ARB_separate_shader_objects (void); +static GLboolean _glewInit_GL_ARB_shader_atomic_counters (void); +static GLboolean _glewInit_GL_ARB_shader_image_load_store (void); +static GLboolean _glewInit_GL_ARB_shader_objects (void); +static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (void); +static GLboolean _glewInit_GL_ARB_shader_subroutine (void); +static GLboolean _glewInit_GL_ARB_shading_language_include (void); +static GLboolean _glewInit_GL_ARB_sparse_buffer (void); +static GLboolean _glewInit_GL_ARB_sparse_texture (void); +static GLboolean _glewInit_GL_ARB_sync (void); +static GLboolean _glewInit_GL_ARB_tessellation_shader (void); +static GLboolean _glewInit_GL_ARB_texture_barrier (void); +static GLboolean _glewInit_GL_ARB_texture_buffer_object (void); +static GLboolean _glewInit_GL_ARB_texture_buffer_range (void); +static GLboolean _glewInit_GL_ARB_texture_compression (void); +static GLboolean _glewInit_GL_ARB_texture_multisample (void); +static GLboolean _glewInit_GL_ARB_texture_storage (void); +static GLboolean _glewInit_GL_ARB_texture_storage_multisample (void); +static GLboolean _glewInit_GL_ARB_texture_view (void); +static GLboolean _glewInit_GL_ARB_timer_query (void); +static GLboolean _glewInit_GL_ARB_transform_feedback2 (void); +static GLboolean _glewInit_GL_ARB_transform_feedback3 (void); +static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (void); +static GLboolean _glewInit_GL_ARB_transpose_matrix (void); +static GLboolean _glewInit_GL_ARB_uniform_buffer_object (void); +static GLboolean _glewInit_GL_ARB_vertex_array_object (void); +static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (void); +static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (void); +static GLboolean _glewInit_GL_ARB_vertex_blend (void); +static GLboolean _glewInit_GL_ARB_vertex_buffer_object (void); +static GLboolean _glewInit_GL_ARB_vertex_program (void); +static GLboolean _glewInit_GL_ARB_vertex_shader (void); +static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (void); +static GLboolean _glewInit_GL_ARB_viewport_array (void); +static GLboolean _glewInit_GL_ARB_window_pos (void); +static GLboolean _glewInit_GL_ARM_shader_core_properties (void); +static GLboolean _glewInit_GL_ATI_draw_buffers (void); +static GLboolean _glewInit_GL_ATI_element_array (void); +static GLboolean _glewInit_GL_ATI_envmap_bumpmap (void); +static GLboolean _glewInit_GL_ATI_fragment_shader (void); +static GLboolean _glewInit_GL_ATI_map_object_buffer (void); +static GLboolean _glewInit_GL_ATI_pn_triangles (void); +static GLboolean _glewInit_GL_ATI_separate_stencil (void); +static GLboolean _glewInit_GL_ATI_vertex_array_object (void); +static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (void); +static GLboolean _glewInit_GL_ATI_vertex_streams (void); +static GLboolean _glewInit_GL_EXT_EGL_image_storage (void); +static GLboolean _glewInit_GL_EXT_base_instance (void); +static GLboolean _glewInit_GL_EXT_bindable_uniform (void); +static GLboolean _glewInit_GL_EXT_blend_color (void); +static GLboolean _glewInit_GL_EXT_blend_equation_separate (void); +static GLboolean _glewInit_GL_EXT_blend_func_extended (void); +static GLboolean _glewInit_GL_EXT_blend_func_separate (void); +static GLboolean _glewInit_GL_EXT_blend_minmax (void); +static GLboolean _glewInit_GL_EXT_buffer_storage (void); +static GLboolean _glewInit_GL_EXT_clear_texture (void); +static GLboolean _glewInit_GL_EXT_clip_control (void); +static GLboolean _glewInit_GL_EXT_color_subtable (void); +static GLboolean _glewInit_GL_EXT_compiled_vertex_array (void); +static GLboolean _glewInit_GL_EXT_convolution (void); +static GLboolean _glewInit_GL_EXT_coordinate_frame (void); +static GLboolean _glewInit_GL_EXT_copy_image (void); +static GLboolean _glewInit_GL_EXT_copy_texture (void); +static GLboolean _glewInit_GL_EXT_cull_vertex (void); +static GLboolean _glewInit_GL_EXT_debug_label (void); +static GLboolean _glewInit_GL_EXT_debug_marker (void); +static GLboolean _glewInit_GL_EXT_depth_bounds_test (void); +static GLboolean _glewInit_GL_EXT_direct_state_access (void); +static GLboolean _glewInit_GL_EXT_discard_framebuffer (void); +static GLboolean _glewInit_GL_EXT_disjoint_timer_query (void); +static GLboolean _glewInit_GL_EXT_draw_buffers (void); +static GLboolean _glewInit_GL_EXT_draw_buffers2 (void); +static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (void); +static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (void); +static GLboolean _glewInit_GL_EXT_draw_instanced (void); +static GLboolean _glewInit_GL_EXT_draw_range_elements (void); +static GLboolean _glewInit_GL_EXT_draw_transform_feedback (void); +static GLboolean _glewInit_GL_EXT_external_buffer (void); +static GLboolean _glewInit_GL_EXT_fog_coord (void); +static GLboolean _glewInit_GL_EXT_fragment_lighting (void); +static GLboolean _glewInit_GL_EXT_fragment_shading_rate (void); +static GLboolean _glewInit_GL_EXT_framebuffer_blit (void); +static GLboolean _glewInit_GL_EXT_framebuffer_blit_layers (void); +static GLboolean _glewInit_GL_EXT_framebuffer_multisample (void); +static GLboolean _glewInit_GL_EXT_framebuffer_object (void); +static GLboolean _glewInit_GL_EXT_geometry_shader4 (void); +static GLboolean _glewInit_GL_EXT_gpu_program_parameters (void); +static GLboolean _glewInit_GL_EXT_gpu_shader4 (void); +static GLboolean _glewInit_GL_EXT_histogram (void); +static GLboolean _glewInit_GL_EXT_index_func (void); +static GLboolean _glewInit_GL_EXT_index_material (void); +static GLboolean _glewInit_GL_EXT_instanced_arrays (void); +static GLboolean _glewInit_GL_EXT_light_texture (void); +static GLboolean _glewInit_GL_EXT_map_buffer_range (void); +static GLboolean _glewInit_GL_EXT_memory_object (void); +static GLboolean _glewInit_GL_EXT_memory_object_fd (void); +static GLboolean _glewInit_GL_EXT_memory_object_win32 (void); +static GLboolean _glewInit_GL_EXT_mesh_shader (void); +static GLboolean _glewInit_GL_EXT_multi_draw_arrays (void); +static GLboolean _glewInit_GL_EXT_multi_draw_indirect (void); +static GLboolean _glewInit_GL_EXT_multisample (void); +static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (void); +static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (void); +static GLboolean _glewInit_GL_EXT_paletted_texture (void); +static GLboolean _glewInit_GL_EXT_pixel_transform (void); +static GLboolean _glewInit_GL_EXT_point_parameters (void); +static GLboolean _glewInit_GL_EXT_polygon_offset (void); +static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (void); +static GLboolean _glewInit_GL_EXT_primitive_bounding_box (void); +static GLboolean _glewInit_GL_EXT_provoking_vertex (void); +static GLboolean _glewInit_GL_EXT_raster_multisample (void); +static GLboolean _glewInit_GL_EXT_robustness (void); +static GLboolean _glewInit_GL_EXT_scene_marker (void); +static GLboolean _glewInit_GL_EXT_secondary_color (void); +static GLboolean _glewInit_GL_EXT_semaphore (void); +static GLboolean _glewInit_GL_EXT_semaphore_fd (void); +static GLboolean _glewInit_GL_EXT_semaphore_win32 (void); +static GLboolean _glewInit_GL_EXT_separate_shader_objects (void); +static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (void); +static GLboolean _glewInit_GL_EXT_shader_image_load_store (void); +static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (void); +static GLboolean _glewInit_GL_EXT_sparse_texture (void); +static GLboolean _glewInit_GL_EXT_stencil_two_side (void); +static GLboolean _glewInit_GL_EXT_subtexture (void); +static GLboolean _glewInit_GL_EXT_tessellation_point_size (void); +static GLboolean _glewInit_GL_EXT_texture3D (void); +static GLboolean _glewInit_GL_EXT_texture_array (void); +static GLboolean _glewInit_GL_EXT_texture_border_clamp (void); +static GLboolean _glewInit_GL_EXT_texture_buffer_object (void); +static GLboolean _glewInit_GL_EXT_texture_integer (void); +static GLboolean _glewInit_GL_EXT_texture_object (void); +static GLboolean _glewInit_GL_EXT_texture_perturb_normal (void); +static GLboolean _glewInit_GL_EXT_texture_storage (void); +static GLboolean _glewInit_GL_EXT_texture_storage_compression (void); +static GLboolean _glewInit_GL_EXT_texture_view (void); +static GLboolean _glewInit_GL_EXT_timer_query (void); +static GLboolean _glewInit_GL_EXT_transform_feedback (void); +static GLboolean _glewInit_GL_EXT_vertex_array (void); +static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (void); +static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (void); +static GLboolean _glewInit_GL_EXT_vertex_shader (void); +static GLboolean _glewInit_GL_EXT_vertex_weighting (void); +static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (void); +static GLboolean _glewInit_GL_EXT_window_rectangles (void); +static GLboolean _glewInit_GL_EXT_x11_sync_object (void); +static GLboolean _glewInit_GL_GREMEDY_frame_terminator (void); +static GLboolean _glewInit_GL_GREMEDY_string_marker (void); +static GLboolean _glewInit_GL_HP_image_transform (void); +static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (void); +static GLboolean _glewInit_GL_IBM_vertex_array_lists (void); +static GLboolean _glewInit_GL_IMG_bindless_texture (void); +static GLboolean _glewInit_GL_IMG_framebuffer_downsample (void); +static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (void); +static GLboolean _glewInit_GL_INTEL_framebuffer_CMAA (void); +static GLboolean _glewInit_GL_INTEL_map_texture (void); +static GLboolean _glewInit_GL_INTEL_parallel_arrays (void); +static GLboolean _glewInit_GL_INTEL_performance_query (void); +static GLboolean _glewInit_GL_INTEL_texture_scissor (void); +static GLboolean _glewInit_GL_KHR_blend_equation_advanced (void); +static GLboolean _glewInit_GL_KHR_debug (void); +static GLboolean _glewInit_GL_KHR_parallel_shader_compile (void); +static GLboolean _glewInit_GL_KHR_robustness (void); +static GLboolean _glewInit_GL_KTX_buffer_region (void); +static GLboolean _glewInit_GL_MESA_framebuffer_flip_y (void); +static GLboolean _glewInit_GL_MESA_resize_buffers (void); +static GLboolean _glewInit_GL_MESA_window_pos (void); +static GLboolean _glewInit_GL_NVX_conditional_render (void); +static GLboolean _glewInit_GL_NVX_gpu_multicast2 (void); +static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (void); +static GLboolean _glewInit_GL_NVX_progress_fence (void); +static GLboolean _glewInit_GL_NV_3dvision_settings (void); +static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control (void); +static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (void); +static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (void); +static GLboolean _glewInit_GL_NV_bindless_texture (void); +static GLboolean _glewInit_GL_NV_blend_equation_advanced (void); +static GLboolean _glewInit_GL_NV_clip_space_w_scaling (void); +static GLboolean _glewInit_GL_NV_command_list (void); +static GLboolean _glewInit_GL_NV_conditional_render (void); +static GLboolean _glewInit_GL_NV_conservative_raster (void); +static GLboolean _glewInit_GL_NV_conservative_raster_dilate (void); +static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (void); +static GLboolean _glewInit_GL_NV_copy_buffer (void); +static GLboolean _glewInit_GL_NV_copy_image (void); +static GLboolean _glewInit_GL_NV_depth_buffer_float (void); +static GLboolean _glewInit_GL_NV_draw_buffers (void); +static GLboolean _glewInit_GL_NV_draw_instanced (void); +static GLboolean _glewInit_GL_NV_draw_texture (void); +static GLboolean _glewInit_GL_NV_draw_vulkan_image (void); +static GLboolean _glewInit_GL_NV_evaluators (void); +static GLboolean _glewInit_GL_NV_explicit_multisample (void); +static GLboolean _glewInit_GL_NV_fence (void); +static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (void); +static GLboolean _glewInit_GL_NV_fragment_program (void); +static GLboolean _glewInit_GL_NV_framebuffer_blit (void); +static GLboolean _glewInit_GL_NV_framebuffer_multisample (void); +static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (void); +static GLboolean _glewInit_GL_NV_geometry_program4 (void); +static GLboolean _glewInit_GL_NV_gpu_multicast (void); +static GLboolean _glewInit_GL_NV_gpu_program4 (void); +static GLboolean _glewInit_GL_NV_gpu_shader5 (void); +static GLboolean _glewInit_GL_NV_half_float (void); +static GLboolean _glewInit_GL_NV_instanced_arrays (void); +static GLboolean _glewInit_GL_NV_internalformat_sample_query (void); +static GLboolean _glewInit_GL_NV_memory_attachment (void); +static GLboolean _glewInit_GL_NV_memory_object_sparse (void); +static GLboolean _glewInit_GL_NV_mesh_shader (void); +static GLboolean _glewInit_GL_NV_non_square_matrices (void); +static GLboolean _glewInit_GL_NV_occlusion_query (void); +static GLboolean _glewInit_GL_NV_parameter_buffer_object (void); +static GLboolean _glewInit_GL_NV_path_rendering (void); +static GLboolean _glewInit_GL_NV_pixel_data_range (void); +static GLboolean _glewInit_GL_NV_point_sprite (void); +static GLboolean _glewInit_GL_NV_polygon_mode (void); +static GLboolean _glewInit_GL_NV_present_video (void); +static GLboolean _glewInit_GL_NV_primitive_restart (void); +static GLboolean _glewInit_GL_NV_read_buffer (void); +static GLboolean _glewInit_GL_NV_register_combiners (void); +static GLboolean _glewInit_GL_NV_register_combiners2 (void); +static GLboolean _glewInit_GL_NV_sample_locations (void); +static GLboolean _glewInit_GL_NV_scissor_exclusive (void); +static GLboolean _glewInit_GL_NV_shader_buffer_load (void); +static GLboolean _glewInit_GL_NV_shading_rate_image (void); +static GLboolean _glewInit_GL_NV_texture_array (void); +static GLboolean _glewInit_GL_NV_texture_barrier (void); +static GLboolean _glewInit_GL_NV_texture_multisample (void); +static GLboolean _glewInit_GL_NV_timeline_semaphore (void); +static GLboolean _glewInit_GL_NV_transform_feedback (void); +static GLboolean _glewInit_GL_NV_transform_feedback2 (void); +static GLboolean _glewInit_GL_NV_vdpau_interop (void); +static GLboolean _glewInit_GL_NV_vdpau_interop2 (void); +static GLboolean _glewInit_GL_NV_vertex_array_range (void); +static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (void); +static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (void); +static GLboolean _glewInit_GL_NV_vertex_program (void); +static GLboolean _glewInit_GL_NV_video_capture (void); +static GLboolean _glewInit_GL_NV_viewport_array (void); +static GLboolean _glewInit_GL_NV_viewport_swizzle (void); +static GLboolean _glewInit_GL_OES_EGL_image (void); +static GLboolean _glewInit_GL_OES_blend_equation_separate (void); +static GLboolean _glewInit_GL_OES_blend_func_separate (void); +static GLboolean _glewInit_GL_OES_blend_subtract (void); +static GLboolean _glewInit_GL_OES_copy_image (void); +static GLboolean _glewInit_GL_OES_draw_buffers_indexed (void); +static GLboolean _glewInit_GL_OES_framebuffer_object (void); +static GLboolean _glewInit_GL_OES_get_program_binary (void); +static GLboolean _glewInit_GL_OES_mapbuffer (void); +static GLboolean _glewInit_GL_OES_matrix_palette (void); +static GLboolean _glewInit_GL_OES_sample_shading (void); +static GLboolean _glewInit_GL_OES_single_precision (void); +static GLboolean _glewInit_GL_OES_texture_3D (void); +static GLboolean _glewInit_GL_OES_texture_border_clamp (void); +static GLboolean _glewInit_GL_OES_texture_buffer (void); +static GLboolean _glewInit_GL_OES_texture_cube_map (void); +static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (void); +static GLboolean _glewInit_GL_OES_texture_view (void); +static GLboolean _glewInit_GL_OES_vertex_array_object (void); +static GLboolean _glewInit_GL_OVR_multiview (void); +static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (void); +static GLboolean _glewInit_GL_QCOM_alpha_test (void); +static GLboolean _glewInit_GL_QCOM_driver_control (void); +static GLboolean _glewInit_GL_QCOM_extended_get (void); +static GLboolean _glewInit_GL_QCOM_extended_get2 (void); +static GLboolean _glewInit_GL_QCOM_frame_extrapolation (void); +static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (void); +static GLboolean _glewInit_GL_QCOM_motion_estimation (void); +static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (void); +static GLboolean _glewInit_GL_QCOM_shading_rate (void); +static GLboolean _glewInit_GL_QCOM_texture_foveated (void); +static GLboolean _glewInit_GL_QCOM_tiled_rendering (void); +static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (void); +static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (void); +static GLboolean _glewInit_GL_REGAL_error_string (void); +static GLboolean _glewInit_GL_REGAL_extension_query (void); +static GLboolean _glewInit_GL_REGAL_log (void); +static GLboolean _glewInit_GL_REGAL_proc_address (void); +static GLboolean _glewInit_GL_SGIS_detail_texture (void); +static GLboolean _glewInit_GL_SGIS_fog_function (void); +static GLboolean _glewInit_GL_SGIS_multisample (void); +static GLboolean _glewInit_GL_SGIS_multitexture (void); +static GLboolean _glewInit_GL_SGIS_shared_multisample (void); +static GLboolean _glewInit_GL_SGIS_sharpen_texture (void); +static GLboolean _glewInit_GL_SGIS_texture4D (void); +static GLboolean _glewInit_GL_SGIS_texture_filter4 (void); +static GLboolean _glewInit_GL_SGIX_async (void); +static GLboolean _glewInit_GL_SGIX_datapipe (void); +static GLboolean _glewInit_GL_SGIX_flush_raster (void); +static GLboolean _glewInit_GL_SGIX_fog_layers (void); +static GLboolean _glewInit_GL_SGIX_fog_texture (void); +static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (void); +static GLboolean _glewInit_GL_SGIX_framezoom (void); +static GLboolean _glewInit_GL_SGIX_igloo_interface (void); +static GLboolean _glewInit_GL_SGIX_mpeg1 (void); +static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (void); +static GLboolean _glewInit_GL_SGIX_pixel_texture (void); +static GLboolean _glewInit_GL_SGIX_polynomial_ffd (void); +static GLboolean _glewInit_GL_SGIX_quad_mesh (void); +static GLboolean _glewInit_GL_SGIX_reference_plane (void); +static GLboolean _glewInit_GL_SGIX_sprite (void); +static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (void); +static GLboolean _glewInit_GL_SGIX_vector_ops (void); +static GLboolean _glewInit_GL_SGIX_vertex_array_object (void); +static GLboolean _glewInit_GL_SGI_color_table (void); +static GLboolean _glewInit_GL_SGI_fft (void); +static GLboolean _glewInit_GL_SUNX_constant_data (void); +static GLboolean _glewInit_GL_SUN_global_alpha (void); +static GLboolean _glewInit_GL_SUN_read_video_pixels (void); +static GLboolean _glewInit_GL_SUN_triangle_list (void); +static GLboolean _glewInit_GL_SUN_vertex (void); +static GLboolean _glewInit_GL_WIN_swap_hint (void); #ifdef GL_VERSION_1_2 -static GLboolean _glewInit_GL_VERSION_1_2 () +static GLboolean _glewInit_GL_VERSION_1_2 (void) { GLboolean r = GL_FALSE; @@ -10412,7 +10702,7 @@ static GLboolean _glewInit_GL_VERSION_1_2 () #ifdef GL_VERSION_1_3 -static GLboolean _glewInit_GL_VERSION_1_3 () +static GLboolean _glewInit_GL_VERSION_1_3 (void) { GLboolean r = GL_FALSE; @@ -10470,7 +10760,7 @@ static GLboolean _glewInit_GL_VERSION_1_3 () #ifdef GL_VERSION_1_4 -static GLboolean _glewInit_GL_VERSION_1_4 () +static GLboolean _glewInit_GL_VERSION_1_4 (void) { GLboolean r = GL_FALSE; @@ -10529,7 +10819,7 @@ static GLboolean _glewInit_GL_VERSION_1_4 () #ifdef GL_VERSION_1_5 -static GLboolean _glewInit_GL_VERSION_1_5 () +static GLboolean _glewInit_GL_VERSION_1_5 (void) { GLboolean r = GL_FALSE; @@ -10560,7 +10850,7 @@ static GLboolean _glewInit_GL_VERSION_1_5 () #ifdef GL_VERSION_2_0 -static GLboolean _glewInit_GL_VERSION_2_0 () +static GLboolean _glewInit_GL_VERSION_2_0 (void) { GLboolean r = GL_FALSE; @@ -10665,7 +10955,7 @@ static GLboolean _glewInit_GL_VERSION_2_0 () #ifdef GL_VERSION_2_1 -static GLboolean _glewInit_GL_VERSION_2_1 () +static GLboolean _glewInit_GL_VERSION_2_1 (void) { GLboolean r = GL_FALSE; @@ -10683,7 +10973,7 @@ static GLboolean _glewInit_GL_VERSION_2_1 () #ifdef GL_VERSION_3_0 -static GLboolean _glewInit_GL_VERSION_3_0 () +static GLboolean _glewInit_GL_VERSION_3_0 (void) { GLboolean r = GL_FALSE; @@ -10755,7 +11045,7 @@ static GLboolean _glewInit_GL_VERSION_3_0 () #ifdef GL_VERSION_3_1 -static GLboolean _glewInit_GL_VERSION_3_1 () +static GLboolean _glewInit_GL_VERSION_3_1 (void) { GLboolean r = GL_FALSE; @@ -10773,7 +11063,7 @@ static GLboolean _glewInit_GL_VERSION_3_1 () #ifdef GL_VERSION_3_2 -static GLboolean _glewInit_GL_VERSION_3_2 () +static GLboolean _glewInit_GL_VERSION_3_2 (void) { GLboolean r = GL_FALSE; @@ -10793,7 +11083,7 @@ static GLboolean _glewInit_GL_VERSION_3_2 () #ifdef GL_VERSION_3_3 -static GLboolean _glewInit_GL_VERSION_3_3 () +static GLboolean _glewInit_GL_VERSION_3_3 (void) { GLboolean r = GL_FALSE; @@ -10806,7 +11096,7 @@ static GLboolean _glewInit_GL_VERSION_3_3 () #ifdef GL_VERSION_4_0 -static GLboolean _glewInit_GL_VERSION_4_0 () +static GLboolean _glewInit_GL_VERSION_4_0 (void) { GLboolean r = GL_FALSE; @@ -10823,7 +11113,7 @@ static GLboolean _glewInit_GL_VERSION_4_0 () #ifdef GL_VERSION_4_5 -static GLboolean _glewInit_GL_VERSION_4_5 () +static GLboolean _glewInit_GL_VERSION_4_5 (void) { GLboolean r = GL_FALSE; @@ -10839,7 +11129,7 @@ static GLboolean _glewInit_GL_VERSION_4_5 () #ifdef GL_VERSION_4_6 -static GLboolean _glewInit_GL_VERSION_4_6 () +static GLboolean _glewInit_GL_VERSION_4_6 (void) { GLboolean r = GL_FALSE; @@ -10854,7 +11144,7 @@ static GLboolean _glewInit_GL_VERSION_4_6 () #ifdef GL_3DFX_tbuffer -static GLboolean _glewInit_GL_3DFX_tbuffer () +static GLboolean _glewInit_GL_3DFX_tbuffer (void) { GLboolean r = GL_FALSE; @@ -10867,7 +11157,7 @@ static GLboolean _glewInit_GL_3DFX_tbuffer () #ifdef GL_AMD_debug_output -static GLboolean _glewInit_GL_AMD_debug_output () +static GLboolean _glewInit_GL_AMD_debug_output (void) { GLboolean r = GL_FALSE; @@ -10883,7 +11173,7 @@ static GLboolean _glewInit_GL_AMD_debug_output () #ifdef GL_AMD_draw_buffers_blend -static GLboolean _glewInit_GL_AMD_draw_buffers_blend () +static GLboolean _glewInit_GL_AMD_draw_buffers_blend (void) { GLboolean r = GL_FALSE; @@ -10899,7 +11189,7 @@ static GLboolean _glewInit_GL_AMD_draw_buffers_blend () #ifdef GL_AMD_framebuffer_multisample_advanced -static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced () +static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (void) { GLboolean r = GL_FALSE; @@ -10913,7 +11203,7 @@ static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced () #ifdef GL_AMD_framebuffer_sample_positions -static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions () +static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (void) { GLboolean r = GL_FALSE; @@ -10929,7 +11219,7 @@ static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions () #ifdef GL_AMD_interleaved_elements -static GLboolean _glewInit_GL_AMD_interleaved_elements () +static GLboolean _glewInit_GL_AMD_interleaved_elements (void) { GLboolean r = GL_FALSE; @@ -10942,7 +11232,7 @@ static GLboolean _glewInit_GL_AMD_interleaved_elements () #ifdef GL_AMD_multi_draw_indirect -static GLboolean _glewInit_GL_AMD_multi_draw_indirect () +static GLboolean _glewInit_GL_AMD_multi_draw_indirect (void) { GLboolean r = GL_FALSE; @@ -10956,7 +11246,7 @@ static GLboolean _glewInit_GL_AMD_multi_draw_indirect () #ifdef GL_AMD_name_gen_delete -static GLboolean _glewInit_GL_AMD_name_gen_delete () +static GLboolean _glewInit_GL_AMD_name_gen_delete (void) { GLboolean r = GL_FALSE; @@ -10971,7 +11261,7 @@ static GLboolean _glewInit_GL_AMD_name_gen_delete () #ifdef GL_AMD_occlusion_query_event -static GLboolean _glewInit_GL_AMD_occlusion_query_event () +static GLboolean _glewInit_GL_AMD_occlusion_query_event (void) { GLboolean r = GL_FALSE; @@ -10984,7 +11274,7 @@ static GLboolean _glewInit_GL_AMD_occlusion_query_event () #ifdef GL_AMD_performance_monitor -static GLboolean _glewInit_GL_AMD_performance_monitor () +static GLboolean _glewInit_GL_AMD_performance_monitor (void) { GLboolean r = GL_FALSE; @@ -11007,7 +11297,7 @@ static GLboolean _glewInit_GL_AMD_performance_monitor () #ifdef GL_AMD_sample_positions -static GLboolean _glewInit_GL_AMD_sample_positions () +static GLboolean _glewInit_GL_AMD_sample_positions (void) { GLboolean r = GL_FALSE; @@ -11020,7 +11310,7 @@ static GLboolean _glewInit_GL_AMD_sample_positions () #ifdef GL_AMD_sparse_texture -static GLboolean _glewInit_GL_AMD_sparse_texture () +static GLboolean _glewInit_GL_AMD_sparse_texture (void) { GLboolean r = GL_FALSE; @@ -11034,7 +11324,7 @@ static GLboolean _glewInit_GL_AMD_sparse_texture () #ifdef GL_AMD_stencil_operation_extended -static GLboolean _glewInit_GL_AMD_stencil_operation_extended () +static GLboolean _glewInit_GL_AMD_stencil_operation_extended (void) { GLboolean r = GL_FALSE; @@ -11047,7 +11337,7 @@ static GLboolean _glewInit_GL_AMD_stencil_operation_extended () #ifdef GL_AMD_vertex_shader_tessellator -static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator () +static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (void) { GLboolean r = GL_FALSE; @@ -11061,7 +11351,7 @@ static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator () #ifdef GL_ANGLE_framebuffer_blit -static GLboolean _glewInit_GL_ANGLE_framebuffer_blit () +static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (void) { GLboolean r = GL_FALSE; @@ -11074,7 +11364,7 @@ static GLboolean _glewInit_GL_ANGLE_framebuffer_blit () #ifdef GL_ANGLE_framebuffer_multisample -static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample () +static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (void) { GLboolean r = GL_FALSE; @@ -11087,7 +11377,7 @@ static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample () #ifdef GL_ANGLE_instanced_arrays -static GLboolean _glewInit_GL_ANGLE_instanced_arrays () +static GLboolean _glewInit_GL_ANGLE_instanced_arrays (void) { GLboolean r = GL_FALSE; @@ -11102,7 +11392,7 @@ static GLboolean _glewInit_GL_ANGLE_instanced_arrays () #ifdef GL_ANGLE_timer_query -static GLboolean _glewInit_GL_ANGLE_timer_query () +static GLboolean _glewInit_GL_ANGLE_timer_query (void) { GLboolean r = GL_FALSE; @@ -11125,7 +11415,7 @@ static GLboolean _glewInit_GL_ANGLE_timer_query () #ifdef GL_ANGLE_translated_shader_source -static GLboolean _glewInit_GL_ANGLE_translated_shader_source () +static GLboolean _glewInit_GL_ANGLE_translated_shader_source (void) { GLboolean r = GL_FALSE; @@ -11138,7 +11428,7 @@ static GLboolean _glewInit_GL_ANGLE_translated_shader_source () #ifdef GL_APPLE_copy_texture_levels -static GLboolean _glewInit_GL_APPLE_copy_texture_levels () +static GLboolean _glewInit_GL_APPLE_copy_texture_levels (void) { GLboolean r = GL_FALSE; @@ -11151,7 +11441,7 @@ static GLboolean _glewInit_GL_APPLE_copy_texture_levels () #ifdef GL_APPLE_element_array -static GLboolean _glewInit_GL_APPLE_element_array () +static GLboolean _glewInit_GL_APPLE_element_array (void) { GLboolean r = GL_FALSE; @@ -11168,7 +11458,7 @@ static GLboolean _glewInit_GL_APPLE_element_array () #ifdef GL_APPLE_fence -static GLboolean _glewInit_GL_APPLE_fence () +static GLboolean _glewInit_GL_APPLE_fence (void) { GLboolean r = GL_FALSE; @@ -11188,7 +11478,7 @@ static GLboolean _glewInit_GL_APPLE_fence () #ifdef GL_APPLE_flush_buffer_range -static GLboolean _glewInit_GL_APPLE_flush_buffer_range () +static GLboolean _glewInit_GL_APPLE_flush_buffer_range (void) { GLboolean r = GL_FALSE; @@ -11202,7 +11492,7 @@ static GLboolean _glewInit_GL_APPLE_flush_buffer_range () #ifdef GL_APPLE_framebuffer_multisample -static GLboolean _glewInit_GL_APPLE_framebuffer_multisample () +static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (void) { GLboolean r = GL_FALSE; @@ -11216,7 +11506,7 @@ static GLboolean _glewInit_GL_APPLE_framebuffer_multisample () #ifdef GL_APPLE_object_purgeable -static GLboolean _glewInit_GL_APPLE_object_purgeable () +static GLboolean _glewInit_GL_APPLE_object_purgeable (void) { GLboolean r = GL_FALSE; @@ -11231,7 +11521,7 @@ static GLboolean _glewInit_GL_APPLE_object_purgeable () #ifdef GL_APPLE_sync -static GLboolean _glewInit_GL_APPLE_sync () +static GLboolean _glewInit_GL_APPLE_sync (void) { GLboolean r = GL_FALSE; @@ -11250,7 +11540,7 @@ static GLboolean _glewInit_GL_APPLE_sync () #ifdef GL_APPLE_texture_range -static GLboolean _glewInit_GL_APPLE_texture_range () +static GLboolean _glewInit_GL_APPLE_texture_range (void) { GLboolean r = GL_FALSE; @@ -11264,7 +11554,7 @@ static GLboolean _glewInit_GL_APPLE_texture_range () #ifdef GL_APPLE_vertex_array_object -static GLboolean _glewInit_GL_APPLE_vertex_array_object () +static GLboolean _glewInit_GL_APPLE_vertex_array_object (void) { GLboolean r = GL_FALSE; @@ -11280,7 +11570,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_array_object () #ifdef GL_APPLE_vertex_array_range -static GLboolean _glewInit_GL_APPLE_vertex_array_range () +static GLboolean _glewInit_GL_APPLE_vertex_array_range (void) { GLboolean r = GL_FALSE; @@ -11295,7 +11585,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_array_range () #ifdef GL_APPLE_vertex_program_evaluators -static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators () +static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (void) { GLboolean r = GL_FALSE; @@ -11314,7 +11604,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators () #ifdef GL_ARB_ES2_compatibility -static GLboolean _glewInit_GL_ARB_ES2_compatibility () +static GLboolean _glewInit_GL_ARB_ES2_compatibility (void) { GLboolean r = GL_FALSE; @@ -11331,7 +11621,7 @@ static GLboolean _glewInit_GL_ARB_ES2_compatibility () #ifdef GL_ARB_ES3_1_compatibility -static GLboolean _glewInit_GL_ARB_ES3_1_compatibility () +static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (void) { GLboolean r = GL_FALSE; @@ -11344,7 +11634,7 @@ static GLboolean _glewInit_GL_ARB_ES3_1_compatibility () #ifdef GL_ARB_ES3_2_compatibility -static GLboolean _glewInit_GL_ARB_ES3_2_compatibility () +static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (void) { GLboolean r = GL_FALSE; @@ -11357,7 +11647,7 @@ static GLboolean _glewInit_GL_ARB_ES3_2_compatibility () #ifdef GL_ARB_base_instance -static GLboolean _glewInit_GL_ARB_base_instance () +static GLboolean _glewInit_GL_ARB_base_instance (void) { GLboolean r = GL_FALSE; @@ -11372,7 +11662,7 @@ static GLboolean _glewInit_GL_ARB_base_instance () #ifdef GL_ARB_bindless_texture -static GLboolean _glewInit_GL_ARB_bindless_texture () +static GLboolean _glewInit_GL_ARB_bindless_texture (void) { GLboolean r = GL_FALSE; @@ -11400,7 +11690,7 @@ static GLboolean _glewInit_GL_ARB_bindless_texture () #ifdef GL_ARB_blend_func_extended -static GLboolean _glewInit_GL_ARB_blend_func_extended () +static GLboolean _glewInit_GL_ARB_blend_func_extended (void) { GLboolean r = GL_FALSE; @@ -11414,7 +11704,7 @@ static GLboolean _glewInit_GL_ARB_blend_func_extended () #ifdef GL_ARB_buffer_storage -static GLboolean _glewInit_GL_ARB_buffer_storage () +static GLboolean _glewInit_GL_ARB_buffer_storage (void) { GLboolean r = GL_FALSE; @@ -11427,7 +11717,7 @@ static GLboolean _glewInit_GL_ARB_buffer_storage () #ifdef GL_ARB_cl_event -static GLboolean _glewInit_GL_ARB_cl_event () +static GLboolean _glewInit_GL_ARB_cl_event (void) { GLboolean r = GL_FALSE; @@ -11440,7 +11730,7 @@ static GLboolean _glewInit_GL_ARB_cl_event () #ifdef GL_ARB_clear_buffer_object -static GLboolean _glewInit_GL_ARB_clear_buffer_object () +static GLboolean _glewInit_GL_ARB_clear_buffer_object (void) { GLboolean r = GL_FALSE; @@ -11456,7 +11746,7 @@ static GLboolean _glewInit_GL_ARB_clear_buffer_object () #ifdef GL_ARB_clear_texture -static GLboolean _glewInit_GL_ARB_clear_texture () +static GLboolean _glewInit_GL_ARB_clear_texture (void) { GLboolean r = GL_FALSE; @@ -11470,7 +11760,7 @@ static GLboolean _glewInit_GL_ARB_clear_texture () #ifdef GL_ARB_clip_control -static GLboolean _glewInit_GL_ARB_clip_control () +static GLboolean _glewInit_GL_ARB_clip_control (void) { GLboolean r = GL_FALSE; @@ -11483,7 +11773,7 @@ static GLboolean _glewInit_GL_ARB_clip_control () #ifdef GL_ARB_color_buffer_float -static GLboolean _glewInit_GL_ARB_color_buffer_float () +static GLboolean _glewInit_GL_ARB_color_buffer_float (void) { GLboolean r = GL_FALSE; @@ -11496,7 +11786,7 @@ static GLboolean _glewInit_GL_ARB_color_buffer_float () #ifdef GL_ARB_compute_shader -static GLboolean _glewInit_GL_ARB_compute_shader () +static GLboolean _glewInit_GL_ARB_compute_shader (void) { GLboolean r = GL_FALSE; @@ -11510,7 +11800,7 @@ static GLboolean _glewInit_GL_ARB_compute_shader () #ifdef GL_ARB_compute_variable_group_size -static GLboolean _glewInit_GL_ARB_compute_variable_group_size () +static GLboolean _glewInit_GL_ARB_compute_variable_group_size (void) { GLboolean r = GL_FALSE; @@ -11523,7 +11813,7 @@ static GLboolean _glewInit_GL_ARB_compute_variable_group_size () #ifdef GL_ARB_copy_buffer -static GLboolean _glewInit_GL_ARB_copy_buffer () +static GLboolean _glewInit_GL_ARB_copy_buffer (void) { GLboolean r = GL_FALSE; @@ -11536,7 +11826,7 @@ static GLboolean _glewInit_GL_ARB_copy_buffer () #ifdef GL_ARB_copy_image -static GLboolean _glewInit_GL_ARB_copy_image () +static GLboolean _glewInit_GL_ARB_copy_image (void) { GLboolean r = GL_FALSE; @@ -11549,7 +11839,7 @@ static GLboolean _glewInit_GL_ARB_copy_image () #ifdef GL_ARB_debug_output -static GLboolean _glewInit_GL_ARB_debug_output () +static GLboolean _glewInit_GL_ARB_debug_output (void) { GLboolean r = GL_FALSE; @@ -11565,7 +11855,7 @@ static GLboolean _glewInit_GL_ARB_debug_output () #ifdef GL_ARB_direct_state_access -static GLboolean _glewInit_GL_ARB_direct_state_access () +static GLboolean _glewInit_GL_ARB_direct_state_access (void) { GLboolean r = GL_FALSE; @@ -11674,7 +11964,7 @@ static GLboolean _glewInit_GL_ARB_direct_state_access () #ifdef GL_ARB_draw_buffers -static GLboolean _glewInit_GL_ARB_draw_buffers () +static GLboolean _glewInit_GL_ARB_draw_buffers (void) { GLboolean r = GL_FALSE; @@ -11687,7 +11977,7 @@ static GLboolean _glewInit_GL_ARB_draw_buffers () #ifdef GL_ARB_draw_buffers_blend -static GLboolean _glewInit_GL_ARB_draw_buffers_blend () +static GLboolean _glewInit_GL_ARB_draw_buffers_blend (void) { GLboolean r = GL_FALSE; @@ -11703,7 +11993,7 @@ static GLboolean _glewInit_GL_ARB_draw_buffers_blend () #ifdef GL_ARB_draw_elements_base_vertex -static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex () +static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (void) { GLboolean r = GL_FALSE; @@ -11719,7 +12009,7 @@ static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex () #ifdef GL_ARB_draw_indirect -static GLboolean _glewInit_GL_ARB_draw_indirect () +static GLboolean _glewInit_GL_ARB_draw_indirect (void) { GLboolean r = GL_FALSE; @@ -11733,7 +12023,7 @@ static GLboolean _glewInit_GL_ARB_draw_indirect () #ifdef GL_ARB_framebuffer_no_attachments -static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments () +static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (void) { GLboolean r = GL_FALSE; @@ -11749,7 +12039,7 @@ static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments () #ifdef GL_ARB_framebuffer_object -static GLboolean _glewInit_GL_ARB_framebuffer_object () +static GLboolean _glewInit_GL_ARB_framebuffer_object (void) { GLboolean r = GL_FALSE; @@ -11781,7 +12071,7 @@ static GLboolean _glewInit_GL_ARB_framebuffer_object () #ifdef GL_ARB_geometry_shader4 -static GLboolean _glewInit_GL_ARB_geometry_shader4 () +static GLboolean _glewInit_GL_ARB_geometry_shader4 (void) { GLboolean r = GL_FALSE; @@ -11797,7 +12087,7 @@ static GLboolean _glewInit_GL_ARB_geometry_shader4 () #ifdef GL_ARB_get_program_binary -static GLboolean _glewInit_GL_ARB_get_program_binary () +static GLboolean _glewInit_GL_ARB_get_program_binary (void) { GLboolean r = GL_FALSE; @@ -11812,7 +12102,7 @@ static GLboolean _glewInit_GL_ARB_get_program_binary () #ifdef GL_ARB_get_texture_sub_image -static GLboolean _glewInit_GL_ARB_get_texture_sub_image () +static GLboolean _glewInit_GL_ARB_get_texture_sub_image (void) { GLboolean r = GL_FALSE; @@ -11826,7 +12116,7 @@ static GLboolean _glewInit_GL_ARB_get_texture_sub_image () #ifdef GL_ARB_gl_spirv -static GLboolean _glewInit_GL_ARB_gl_spirv () +static GLboolean _glewInit_GL_ARB_gl_spirv (void) { GLboolean r = GL_FALSE; @@ -11839,7 +12129,7 @@ static GLboolean _glewInit_GL_ARB_gl_spirv () #ifdef GL_ARB_gpu_shader_fp64 -static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 () +static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (void) { GLboolean r = GL_FALSE; @@ -11869,7 +12159,7 @@ static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 () #ifdef GL_ARB_gpu_shader_int64 -static GLboolean _glewInit_GL_ARB_gpu_shader_int64 () +static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (void) { GLboolean r = GL_FALSE; @@ -11917,7 +12207,7 @@ static GLboolean _glewInit_GL_ARB_gpu_shader_int64 () #ifdef GL_ARB_imaging -static GLboolean _glewInit_GL_ARB_imaging () +static GLboolean _glewInit_GL_ARB_imaging (void) { GLboolean r = GL_FALSE; @@ -11962,7 +12252,7 @@ static GLboolean _glewInit_GL_ARB_imaging () #ifdef GL_ARB_indirect_parameters -static GLboolean _glewInit_GL_ARB_indirect_parameters () +static GLboolean _glewInit_GL_ARB_indirect_parameters (void) { GLboolean r = GL_FALSE; @@ -11976,7 +12266,7 @@ static GLboolean _glewInit_GL_ARB_indirect_parameters () #ifdef GL_ARB_instanced_arrays -static GLboolean _glewInit_GL_ARB_instanced_arrays () +static GLboolean _glewInit_GL_ARB_instanced_arrays (void) { GLboolean r = GL_FALSE; @@ -11991,7 +12281,7 @@ static GLboolean _glewInit_GL_ARB_instanced_arrays () #ifdef GL_ARB_internalformat_query -static GLboolean _glewInit_GL_ARB_internalformat_query () +static GLboolean _glewInit_GL_ARB_internalformat_query (void) { GLboolean r = GL_FALSE; @@ -12004,7 +12294,7 @@ static GLboolean _glewInit_GL_ARB_internalformat_query () #ifdef GL_ARB_internalformat_query2 -static GLboolean _glewInit_GL_ARB_internalformat_query2 () +static GLboolean _glewInit_GL_ARB_internalformat_query2 (void) { GLboolean r = GL_FALSE; @@ -12017,7 +12307,7 @@ static GLboolean _glewInit_GL_ARB_internalformat_query2 () #ifdef GL_ARB_invalidate_subdata -static GLboolean _glewInit_GL_ARB_invalidate_subdata () +static GLboolean _glewInit_GL_ARB_invalidate_subdata (void) { GLboolean r = GL_FALSE; @@ -12035,7 +12325,7 @@ static GLboolean _glewInit_GL_ARB_invalidate_subdata () #ifdef GL_ARB_map_buffer_range -static GLboolean _glewInit_GL_ARB_map_buffer_range () +static GLboolean _glewInit_GL_ARB_map_buffer_range (void) { GLboolean r = GL_FALSE; @@ -12049,7 +12339,7 @@ static GLboolean _glewInit_GL_ARB_map_buffer_range () #ifdef GL_ARB_matrix_palette -static GLboolean _glewInit_GL_ARB_matrix_palette () +static GLboolean _glewInit_GL_ARB_matrix_palette (void) { GLboolean r = GL_FALSE; @@ -12066,7 +12356,7 @@ static GLboolean _glewInit_GL_ARB_matrix_palette () #ifdef GL_ARB_multi_bind -static GLboolean _glewInit_GL_ARB_multi_bind () +static GLboolean _glewInit_GL_ARB_multi_bind (void) { GLboolean r = GL_FALSE; @@ -12084,7 +12374,7 @@ static GLboolean _glewInit_GL_ARB_multi_bind () #ifdef GL_ARB_multi_draw_indirect -static GLboolean _glewInit_GL_ARB_multi_draw_indirect () +static GLboolean _glewInit_GL_ARB_multi_draw_indirect (void) { GLboolean r = GL_FALSE; @@ -12098,7 +12388,7 @@ static GLboolean _glewInit_GL_ARB_multi_draw_indirect () #ifdef GL_ARB_multisample -static GLboolean _glewInit_GL_ARB_multisample () +static GLboolean _glewInit_GL_ARB_multisample (void) { GLboolean r = GL_FALSE; @@ -12111,7 +12401,7 @@ static GLboolean _glewInit_GL_ARB_multisample () #ifdef GL_ARB_multitexture -static GLboolean _glewInit_GL_ARB_multitexture () +static GLboolean _glewInit_GL_ARB_multitexture (void) { GLboolean r = GL_FALSE; @@ -12157,7 +12447,7 @@ static GLboolean _glewInit_GL_ARB_multitexture () #ifdef GL_ARB_occlusion_query -static GLboolean _glewInit_GL_ARB_occlusion_query () +static GLboolean _glewInit_GL_ARB_occlusion_query (void) { GLboolean r = GL_FALSE; @@ -12177,7 +12467,7 @@ static GLboolean _glewInit_GL_ARB_occlusion_query () #ifdef GL_ARB_parallel_shader_compile -static GLboolean _glewInit_GL_ARB_parallel_shader_compile () +static GLboolean _glewInit_GL_ARB_parallel_shader_compile (void) { GLboolean r = GL_FALSE; @@ -12190,7 +12480,7 @@ static GLboolean _glewInit_GL_ARB_parallel_shader_compile () #ifdef GL_ARB_point_parameters -static GLboolean _glewInit_GL_ARB_point_parameters () +static GLboolean _glewInit_GL_ARB_point_parameters (void) { GLboolean r = GL_FALSE; @@ -12204,7 +12494,7 @@ static GLboolean _glewInit_GL_ARB_point_parameters () #ifdef GL_ARB_polygon_offset_clamp -static GLboolean _glewInit_GL_ARB_polygon_offset_clamp () +static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (void) { GLboolean r = GL_FALSE; @@ -12217,7 +12507,7 @@ static GLboolean _glewInit_GL_ARB_polygon_offset_clamp () #ifdef GL_ARB_program_interface_query -static GLboolean _glewInit_GL_ARB_program_interface_query () +static GLboolean _glewInit_GL_ARB_program_interface_query (void) { GLboolean r = GL_FALSE; @@ -12235,7 +12525,7 @@ static GLboolean _glewInit_GL_ARB_program_interface_query () #ifdef GL_ARB_provoking_vertex -static GLboolean _glewInit_GL_ARB_provoking_vertex () +static GLboolean _glewInit_GL_ARB_provoking_vertex (void) { GLboolean r = GL_FALSE; @@ -12248,7 +12538,7 @@ static GLboolean _glewInit_GL_ARB_provoking_vertex () #ifdef GL_ARB_robustness -static GLboolean _glewInit_GL_ARB_robustness () +static GLboolean _glewInit_GL_ARB_robustness (void) { GLboolean r = GL_FALSE; @@ -12280,10 +12570,11 @@ static GLboolean _glewInit_GL_ARB_robustness () #ifdef GL_ARB_sample_locations -static GLboolean _glewInit_GL_ARB_sample_locations () +static GLboolean _glewInit_GL_ARB_sample_locations (void) { GLboolean r = GL_FALSE; + r = ((glEvaluateDepthValuesARB = (PFNGLEVALUATEDEPTHVALUESARBPROC)glewGetProcAddress((const GLubyte*)"glEvaluateDepthValuesARB")) == NULL) || r; r = ((glFramebufferSampleLocationsfvARB = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvARB")) == NULL) || r; r = ((glNamedFramebufferSampleLocationsfvARB = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvARB")) == NULL) || r; @@ -12294,7 +12585,7 @@ static GLboolean _glewInit_GL_ARB_sample_locations () #ifdef GL_ARB_sample_shading -static GLboolean _glewInit_GL_ARB_sample_shading () +static GLboolean _glewInit_GL_ARB_sample_shading (void) { GLboolean r = GL_FALSE; @@ -12307,7 +12598,7 @@ static GLboolean _glewInit_GL_ARB_sample_shading () #ifdef GL_ARB_sampler_objects -static GLboolean _glewInit_GL_ARB_sampler_objects () +static GLboolean _glewInit_GL_ARB_sampler_objects (void) { GLboolean r = GL_FALSE; @@ -12333,7 +12624,7 @@ static GLboolean _glewInit_GL_ARB_sampler_objects () #ifdef GL_ARB_separate_shader_objects -static GLboolean _glewInit_GL_ARB_separate_shader_objects () +static GLboolean _glewInit_GL_ARB_separate_shader_objects (void) { GLboolean r = GL_FALSE; @@ -12405,7 +12696,7 @@ static GLboolean _glewInit_GL_ARB_separate_shader_objects () #ifdef GL_ARB_shader_atomic_counters -static GLboolean _glewInit_GL_ARB_shader_atomic_counters () +static GLboolean _glewInit_GL_ARB_shader_atomic_counters (void) { GLboolean r = GL_FALSE; @@ -12418,7 +12709,7 @@ static GLboolean _glewInit_GL_ARB_shader_atomic_counters () #ifdef GL_ARB_shader_image_load_store -static GLboolean _glewInit_GL_ARB_shader_image_load_store () +static GLboolean _glewInit_GL_ARB_shader_image_load_store (void) { GLboolean r = GL_FALSE; @@ -12432,7 +12723,7 @@ static GLboolean _glewInit_GL_ARB_shader_image_load_store () #ifdef GL_ARB_shader_objects -static GLboolean _glewInit_GL_ARB_shader_objects () +static GLboolean _glewInit_GL_ARB_shader_objects (void) { GLboolean r = GL_FALSE; @@ -12483,7 +12774,7 @@ static GLboolean _glewInit_GL_ARB_shader_objects () #ifdef GL_ARB_shader_storage_buffer_object -static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object () +static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (void) { GLboolean r = GL_FALSE; @@ -12496,7 +12787,7 @@ static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object () #ifdef GL_ARB_shader_subroutine -static GLboolean _glewInit_GL_ARB_shader_subroutine () +static GLboolean _glewInit_GL_ARB_shader_subroutine (void) { GLboolean r = GL_FALSE; @@ -12516,7 +12807,7 @@ static GLboolean _glewInit_GL_ARB_shader_subroutine () #ifdef GL_ARB_shading_language_include -static GLboolean _glewInit_GL_ARB_shading_language_include () +static GLboolean _glewInit_GL_ARB_shading_language_include (void) { GLboolean r = GL_FALSE; @@ -12534,7 +12825,7 @@ static GLboolean _glewInit_GL_ARB_shading_language_include () #ifdef GL_ARB_sparse_buffer -static GLboolean _glewInit_GL_ARB_sparse_buffer () +static GLboolean _glewInit_GL_ARB_sparse_buffer (void) { GLboolean r = GL_FALSE; @@ -12547,7 +12838,7 @@ static GLboolean _glewInit_GL_ARB_sparse_buffer () #ifdef GL_ARB_sparse_texture -static GLboolean _glewInit_GL_ARB_sparse_texture () +static GLboolean _glewInit_GL_ARB_sparse_texture (void) { GLboolean r = GL_FALSE; @@ -12560,7 +12851,7 @@ static GLboolean _glewInit_GL_ARB_sparse_texture () #ifdef GL_ARB_sync -static GLboolean _glewInit_GL_ARB_sync () +static GLboolean _glewInit_GL_ARB_sync (void) { GLboolean r = GL_FALSE; @@ -12579,7 +12870,7 @@ static GLboolean _glewInit_GL_ARB_sync () #ifdef GL_ARB_tessellation_shader -static GLboolean _glewInit_GL_ARB_tessellation_shader () +static GLboolean _glewInit_GL_ARB_tessellation_shader (void) { GLboolean r = GL_FALSE; @@ -12593,7 +12884,7 @@ static GLboolean _glewInit_GL_ARB_tessellation_shader () #ifdef GL_ARB_texture_barrier -static GLboolean _glewInit_GL_ARB_texture_barrier () +static GLboolean _glewInit_GL_ARB_texture_barrier (void) { GLboolean r = GL_FALSE; @@ -12606,7 +12897,7 @@ static GLboolean _glewInit_GL_ARB_texture_barrier () #ifdef GL_ARB_texture_buffer_object -static GLboolean _glewInit_GL_ARB_texture_buffer_object () +static GLboolean _glewInit_GL_ARB_texture_buffer_object (void) { GLboolean r = GL_FALSE; @@ -12619,7 +12910,7 @@ static GLboolean _glewInit_GL_ARB_texture_buffer_object () #ifdef GL_ARB_texture_buffer_range -static GLboolean _glewInit_GL_ARB_texture_buffer_range () +static GLboolean _glewInit_GL_ARB_texture_buffer_range (void) { GLboolean r = GL_FALSE; @@ -12633,7 +12924,7 @@ static GLboolean _glewInit_GL_ARB_texture_buffer_range () #ifdef GL_ARB_texture_compression -static GLboolean _glewInit_GL_ARB_texture_compression () +static GLboolean _glewInit_GL_ARB_texture_compression (void) { GLboolean r = GL_FALSE; @@ -12652,7 +12943,7 @@ static GLboolean _glewInit_GL_ARB_texture_compression () #ifdef GL_ARB_texture_multisample -static GLboolean _glewInit_GL_ARB_texture_multisample () +static GLboolean _glewInit_GL_ARB_texture_multisample (void) { GLboolean r = GL_FALSE; @@ -12668,7 +12959,7 @@ static GLboolean _glewInit_GL_ARB_texture_multisample () #ifdef GL_ARB_texture_storage -static GLboolean _glewInit_GL_ARB_texture_storage () +static GLboolean _glewInit_GL_ARB_texture_storage (void) { GLboolean r = GL_FALSE; @@ -12683,7 +12974,7 @@ static GLboolean _glewInit_GL_ARB_texture_storage () #ifdef GL_ARB_texture_storage_multisample -static GLboolean _glewInit_GL_ARB_texture_storage_multisample () +static GLboolean _glewInit_GL_ARB_texture_storage_multisample (void) { GLboolean r = GL_FALSE; @@ -12699,7 +12990,7 @@ static GLboolean _glewInit_GL_ARB_texture_storage_multisample () #ifdef GL_ARB_texture_view -static GLboolean _glewInit_GL_ARB_texture_view () +static GLboolean _glewInit_GL_ARB_texture_view (void) { GLboolean r = GL_FALSE; @@ -12712,7 +13003,7 @@ static GLboolean _glewInit_GL_ARB_texture_view () #ifdef GL_ARB_timer_query -static GLboolean _glewInit_GL_ARB_timer_query () +static GLboolean _glewInit_GL_ARB_timer_query (void) { GLboolean r = GL_FALSE; @@ -12727,7 +13018,7 @@ static GLboolean _glewInit_GL_ARB_timer_query () #ifdef GL_ARB_transform_feedback2 -static GLboolean _glewInit_GL_ARB_transform_feedback2 () +static GLboolean _glewInit_GL_ARB_transform_feedback2 (void) { GLboolean r = GL_FALSE; @@ -12746,7 +13037,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback2 () #ifdef GL_ARB_transform_feedback3 -static GLboolean _glewInit_GL_ARB_transform_feedback3 () +static GLboolean _glewInit_GL_ARB_transform_feedback3 (void) { GLboolean r = GL_FALSE; @@ -12762,7 +13053,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback3 () #ifdef GL_ARB_transform_feedback_instanced -static GLboolean _glewInit_GL_ARB_transform_feedback_instanced () +static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (void) { GLboolean r = GL_FALSE; @@ -12776,7 +13067,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback_instanced () #ifdef GL_ARB_transpose_matrix -static GLboolean _glewInit_GL_ARB_transpose_matrix () +static GLboolean _glewInit_GL_ARB_transpose_matrix (void) { GLboolean r = GL_FALSE; @@ -12792,7 +13083,7 @@ static GLboolean _glewInit_GL_ARB_transpose_matrix () #ifdef GL_ARB_uniform_buffer_object -static GLboolean _glewInit_GL_ARB_uniform_buffer_object () +static GLboolean _glewInit_GL_ARB_uniform_buffer_object (void) { GLboolean r = GL_FALSE; @@ -12814,7 +13105,7 @@ static GLboolean _glewInit_GL_ARB_uniform_buffer_object () #ifdef GL_ARB_vertex_array_object -static GLboolean _glewInit_GL_ARB_vertex_array_object () +static GLboolean _glewInit_GL_ARB_vertex_array_object (void) { GLboolean r = GL_FALSE; @@ -12830,7 +13121,7 @@ static GLboolean _glewInit_GL_ARB_vertex_array_object () #ifdef GL_ARB_vertex_attrib_64bit -static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit () +static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (void) { GLboolean r = GL_FALSE; @@ -12852,7 +13143,7 @@ static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit () #ifdef GL_ARB_vertex_attrib_binding -static GLboolean _glewInit_GL_ARB_vertex_attrib_binding () +static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (void) { GLboolean r = GL_FALSE; @@ -12876,7 +13167,7 @@ static GLboolean _glewInit_GL_ARB_vertex_attrib_binding () #ifdef GL_ARB_vertex_blend -static GLboolean _glewInit_GL_ARB_vertex_blend () +static GLboolean _glewInit_GL_ARB_vertex_blend (void) { GLboolean r = GL_FALSE; @@ -12898,7 +13189,7 @@ static GLboolean _glewInit_GL_ARB_vertex_blend () #ifdef GL_ARB_vertex_buffer_object -static GLboolean _glewInit_GL_ARB_vertex_buffer_object () +static GLboolean _glewInit_GL_ARB_vertex_buffer_object (void) { GLboolean r = GL_FALSE; @@ -12921,7 +13212,7 @@ static GLboolean _glewInit_GL_ARB_vertex_buffer_object () #ifdef GL_ARB_vertex_program -static GLboolean _glewInit_GL_ARB_vertex_program () +static GLboolean _glewInit_GL_ARB_vertex_program (void) { GLboolean r = GL_FALSE; @@ -12995,7 +13286,7 @@ static GLboolean _glewInit_GL_ARB_vertex_program () #ifdef GL_ARB_vertex_shader -static GLboolean _glewInit_GL_ARB_vertex_shader () +static GLboolean _glewInit_GL_ARB_vertex_shader (void) { GLboolean r = GL_FALSE; @@ -13010,7 +13301,7 @@ static GLboolean _glewInit_GL_ARB_vertex_shader () #ifdef GL_ARB_vertex_type_2_10_10_10_rev -static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev () +static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (void) { GLboolean r = GL_FALSE; @@ -13060,7 +13351,7 @@ static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev () #ifdef GL_ARB_viewport_array -static GLboolean _glewInit_GL_ARB_viewport_array () +static GLboolean _glewInit_GL_ARB_viewport_array (void) { GLboolean r = GL_FALSE; @@ -13082,7 +13373,7 @@ static GLboolean _glewInit_GL_ARB_viewport_array () #ifdef GL_ARB_window_pos -static GLboolean _glewInit_GL_ARB_window_pos () +static GLboolean _glewInit_GL_ARB_window_pos (void) { GLboolean r = GL_FALSE; @@ -13108,9 +13399,22 @@ static GLboolean _glewInit_GL_ARB_window_pos () #endif /* GL_ARB_window_pos */ +#ifdef GL_ARM_shader_core_properties + +static GLboolean _glewInit_GL_ARM_shader_core_properties (void) +{ + GLboolean r = GL_FALSE; + + r = ((glMaxActiveShaderCoresARM = (PFNGLMAXACTIVESHADERCORESARMPROC)glewGetProcAddress((const GLubyte*)"glMaxActiveShaderCoresARM")) == NULL) || r; + + return r; +} + +#endif /* GL_ARM_shader_core_properties */ + #ifdef GL_ATI_draw_buffers -static GLboolean _glewInit_GL_ATI_draw_buffers () +static GLboolean _glewInit_GL_ATI_draw_buffers (void) { GLboolean r = GL_FALSE; @@ -13123,7 +13427,7 @@ static GLboolean _glewInit_GL_ATI_draw_buffers () #ifdef GL_ATI_element_array -static GLboolean _glewInit_GL_ATI_element_array () +static GLboolean _glewInit_GL_ATI_element_array (void) { GLboolean r = GL_FALSE; @@ -13138,7 +13442,7 @@ static GLboolean _glewInit_GL_ATI_element_array () #ifdef GL_ATI_envmap_bumpmap -static GLboolean _glewInit_GL_ATI_envmap_bumpmap () +static GLboolean _glewInit_GL_ATI_envmap_bumpmap (void) { GLboolean r = GL_FALSE; @@ -13154,7 +13458,7 @@ static GLboolean _glewInit_GL_ATI_envmap_bumpmap () #ifdef GL_ATI_fragment_shader -static GLboolean _glewInit_GL_ATI_fragment_shader () +static GLboolean _glewInit_GL_ATI_fragment_shader (void) { GLboolean r = GL_FALSE; @@ -13180,7 +13484,7 @@ static GLboolean _glewInit_GL_ATI_fragment_shader () #ifdef GL_ATI_map_object_buffer -static GLboolean _glewInit_GL_ATI_map_object_buffer () +static GLboolean _glewInit_GL_ATI_map_object_buffer (void) { GLboolean r = GL_FALSE; @@ -13194,7 +13498,7 @@ static GLboolean _glewInit_GL_ATI_map_object_buffer () #ifdef GL_ATI_pn_triangles -static GLboolean _glewInit_GL_ATI_pn_triangles () +static GLboolean _glewInit_GL_ATI_pn_triangles (void) { GLboolean r = GL_FALSE; @@ -13208,7 +13512,7 @@ static GLboolean _glewInit_GL_ATI_pn_triangles () #ifdef GL_ATI_separate_stencil -static GLboolean _glewInit_GL_ATI_separate_stencil () +static GLboolean _glewInit_GL_ATI_separate_stencil (void) { GLboolean r = GL_FALSE; @@ -13222,7 +13526,7 @@ static GLboolean _glewInit_GL_ATI_separate_stencil () #ifdef GL_ATI_vertex_array_object -static GLboolean _glewInit_GL_ATI_vertex_array_object () +static GLboolean _glewInit_GL_ATI_vertex_array_object (void) { GLboolean r = GL_FALSE; @@ -13246,7 +13550,7 @@ static GLboolean _glewInit_GL_ATI_vertex_array_object () #ifdef GL_ATI_vertex_attrib_array_object -static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object () +static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (void) { GLboolean r = GL_FALSE; @@ -13261,7 +13565,7 @@ static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object () #ifdef GL_ATI_vertex_streams -static GLboolean _glewInit_GL_ATI_vertex_streams () +static GLboolean _glewInit_GL_ATI_vertex_streams (void) { GLboolean r = GL_FALSE; @@ -13318,7 +13622,7 @@ static GLboolean _glewInit_GL_ATI_vertex_streams () #ifdef GL_EXT_EGL_image_storage -static GLboolean _glewInit_GL_EXT_EGL_image_storage () +static GLboolean _glewInit_GL_EXT_EGL_image_storage (void) { GLboolean r = GL_FALSE; @@ -13332,7 +13636,7 @@ static GLboolean _glewInit_GL_EXT_EGL_image_storage () #ifdef GL_EXT_base_instance -static GLboolean _glewInit_GL_EXT_base_instance () +static GLboolean _glewInit_GL_EXT_base_instance (void) { GLboolean r = GL_FALSE; @@ -13347,7 +13651,7 @@ static GLboolean _glewInit_GL_EXT_base_instance () #ifdef GL_EXT_bindable_uniform -static GLboolean _glewInit_GL_EXT_bindable_uniform () +static GLboolean _glewInit_GL_EXT_bindable_uniform (void) { GLboolean r = GL_FALSE; @@ -13362,7 +13666,7 @@ static GLboolean _glewInit_GL_EXT_bindable_uniform () #ifdef GL_EXT_blend_color -static GLboolean _glewInit_GL_EXT_blend_color () +static GLboolean _glewInit_GL_EXT_blend_color (void) { GLboolean r = GL_FALSE; @@ -13375,7 +13679,7 @@ static GLboolean _glewInit_GL_EXT_blend_color () #ifdef GL_EXT_blend_equation_separate -static GLboolean _glewInit_GL_EXT_blend_equation_separate () +static GLboolean _glewInit_GL_EXT_blend_equation_separate (void) { GLboolean r = GL_FALSE; @@ -13388,7 +13692,7 @@ static GLboolean _glewInit_GL_EXT_blend_equation_separate () #ifdef GL_EXT_blend_func_extended -static GLboolean _glewInit_GL_EXT_blend_func_extended () +static GLboolean _glewInit_GL_EXT_blend_func_extended (void) { GLboolean r = GL_FALSE; @@ -13403,7 +13707,7 @@ static GLboolean _glewInit_GL_EXT_blend_func_extended () #ifdef GL_EXT_blend_func_separate -static GLboolean _glewInit_GL_EXT_blend_func_separate () +static GLboolean _glewInit_GL_EXT_blend_func_separate (void) { GLboolean r = GL_FALSE; @@ -13416,7 +13720,7 @@ static GLboolean _glewInit_GL_EXT_blend_func_separate () #ifdef GL_EXT_blend_minmax -static GLboolean _glewInit_GL_EXT_blend_minmax () +static GLboolean _glewInit_GL_EXT_blend_minmax (void) { GLboolean r = GL_FALSE; @@ -13429,12 +13733,11 @@ static GLboolean _glewInit_GL_EXT_blend_minmax () #ifdef GL_EXT_buffer_storage -static GLboolean _glewInit_GL_EXT_buffer_storage () +static GLboolean _glewInit_GL_EXT_buffer_storage (void) { GLboolean r = GL_FALSE; r = ((glBufferStorageEXT = (PFNGLBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageEXT")) == NULL) || r; - r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r; return r; } @@ -13443,7 +13746,7 @@ static GLboolean _glewInit_GL_EXT_buffer_storage () #ifdef GL_EXT_clear_texture -static GLboolean _glewInit_GL_EXT_clear_texture () +static GLboolean _glewInit_GL_EXT_clear_texture (void) { GLboolean r = GL_FALSE; @@ -13457,7 +13760,7 @@ static GLboolean _glewInit_GL_EXT_clear_texture () #ifdef GL_EXT_clip_control -static GLboolean _glewInit_GL_EXT_clip_control () +static GLboolean _glewInit_GL_EXT_clip_control (void) { GLboolean r = GL_FALSE; @@ -13470,7 +13773,7 @@ static GLboolean _glewInit_GL_EXT_clip_control () #ifdef GL_EXT_color_subtable -static GLboolean _glewInit_GL_EXT_color_subtable () +static GLboolean _glewInit_GL_EXT_color_subtable (void) { GLboolean r = GL_FALSE; @@ -13484,7 +13787,7 @@ static GLboolean _glewInit_GL_EXT_color_subtable () #ifdef GL_EXT_compiled_vertex_array -static GLboolean _glewInit_GL_EXT_compiled_vertex_array () +static GLboolean _glewInit_GL_EXT_compiled_vertex_array (void) { GLboolean r = GL_FALSE; @@ -13498,7 +13801,7 @@ static GLboolean _glewInit_GL_EXT_compiled_vertex_array () #ifdef GL_EXT_convolution -static GLboolean _glewInit_GL_EXT_convolution () +static GLboolean _glewInit_GL_EXT_convolution (void) { GLboolean r = GL_FALSE; @@ -13523,7 +13826,7 @@ static GLboolean _glewInit_GL_EXT_convolution () #ifdef GL_EXT_coordinate_frame -static GLboolean _glewInit_GL_EXT_coordinate_frame () +static GLboolean _glewInit_GL_EXT_coordinate_frame (void) { GLboolean r = GL_FALSE; @@ -13537,7 +13840,7 @@ static GLboolean _glewInit_GL_EXT_coordinate_frame () #ifdef GL_EXT_copy_image -static GLboolean _glewInit_GL_EXT_copy_image () +static GLboolean _glewInit_GL_EXT_copy_image (void) { GLboolean r = GL_FALSE; @@ -13550,7 +13853,7 @@ static GLboolean _glewInit_GL_EXT_copy_image () #ifdef GL_EXT_copy_texture -static GLboolean _glewInit_GL_EXT_copy_texture () +static GLboolean _glewInit_GL_EXT_copy_texture (void) { GLboolean r = GL_FALSE; @@ -13567,7 +13870,7 @@ static GLboolean _glewInit_GL_EXT_copy_texture () #ifdef GL_EXT_cull_vertex -static GLboolean _glewInit_GL_EXT_cull_vertex () +static GLboolean _glewInit_GL_EXT_cull_vertex (void) { GLboolean r = GL_FALSE; @@ -13581,7 +13884,7 @@ static GLboolean _glewInit_GL_EXT_cull_vertex () #ifdef GL_EXT_debug_label -static GLboolean _glewInit_GL_EXT_debug_label () +static GLboolean _glewInit_GL_EXT_debug_label (void) { GLboolean r = GL_FALSE; @@ -13595,7 +13898,7 @@ static GLboolean _glewInit_GL_EXT_debug_label () #ifdef GL_EXT_debug_marker -static GLboolean _glewInit_GL_EXT_debug_marker () +static GLboolean _glewInit_GL_EXT_debug_marker (void) { GLboolean r = GL_FALSE; @@ -13610,7 +13913,7 @@ static GLboolean _glewInit_GL_EXT_debug_marker () #ifdef GL_EXT_depth_bounds_test -static GLboolean _glewInit_GL_EXT_depth_bounds_test () +static GLboolean _glewInit_GL_EXT_depth_bounds_test (void) { GLboolean r = GL_FALSE; @@ -13623,7 +13926,7 @@ static GLboolean _glewInit_GL_EXT_depth_bounds_test () #ifdef GL_EXT_direct_state_access -static GLboolean _glewInit_GL_EXT_direct_state_access () +static GLboolean _glewInit_GL_EXT_direct_state_access (void) { GLboolean r = GL_FALSE; @@ -13818,6 +14121,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access () r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r; r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r; r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r; + r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r; r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r; r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r; r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r; @@ -13849,7 +14153,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access () #ifdef GL_EXT_discard_framebuffer -static GLboolean _glewInit_GL_EXT_discard_framebuffer () +static GLboolean _glewInit_GL_EXT_discard_framebuffer (void) { GLboolean r = GL_FALSE; @@ -13862,7 +14166,7 @@ static GLboolean _glewInit_GL_EXT_discard_framebuffer () #ifdef GL_EXT_disjoint_timer_query -static GLboolean _glewInit_GL_EXT_disjoint_timer_query () +static GLboolean _glewInit_GL_EXT_disjoint_timer_query (void) { GLboolean r = GL_FALSE; @@ -13884,7 +14188,7 @@ static GLboolean _glewInit_GL_EXT_disjoint_timer_query () #ifdef GL_EXT_draw_buffers -static GLboolean _glewInit_GL_EXT_draw_buffers () +static GLboolean _glewInit_GL_EXT_draw_buffers (void) { GLboolean r = GL_FALSE; @@ -13897,7 +14201,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers () #ifdef GL_EXT_draw_buffers2 -static GLboolean _glewInit_GL_EXT_draw_buffers2 () +static GLboolean _glewInit_GL_EXT_draw_buffers2 (void) { GLboolean r = GL_FALSE; @@ -13915,7 +14219,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers2 () #ifdef GL_EXT_draw_buffers_indexed -static GLboolean _glewInit_GL_EXT_draw_buffers_indexed () +static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (void) { GLboolean r = GL_FALSE; @@ -13935,7 +14239,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers_indexed () #ifdef GL_EXT_draw_elements_base_vertex -static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex () +static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (void) { GLboolean r = GL_FALSE; @@ -13951,7 +14255,7 @@ static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex () #ifdef GL_EXT_draw_instanced -static GLboolean _glewInit_GL_EXT_draw_instanced () +static GLboolean _glewInit_GL_EXT_draw_instanced (void) { GLboolean r = GL_FALSE; @@ -13965,7 +14269,7 @@ static GLboolean _glewInit_GL_EXT_draw_instanced () #ifdef GL_EXT_draw_range_elements -static GLboolean _glewInit_GL_EXT_draw_range_elements () +static GLboolean _glewInit_GL_EXT_draw_range_elements (void) { GLboolean r = GL_FALSE; @@ -13978,7 +14282,7 @@ static GLboolean _glewInit_GL_EXT_draw_range_elements () #ifdef GL_EXT_draw_transform_feedback -static GLboolean _glewInit_GL_EXT_draw_transform_feedback () +static GLboolean _glewInit_GL_EXT_draw_transform_feedback (void) { GLboolean r = GL_FALSE; @@ -13992,7 +14296,7 @@ static GLboolean _glewInit_GL_EXT_draw_transform_feedback () #ifdef GL_EXT_external_buffer -static GLboolean _glewInit_GL_EXT_external_buffer () +static GLboolean _glewInit_GL_EXT_external_buffer (void) { GLboolean r = GL_FALSE; @@ -14006,7 +14310,7 @@ static GLboolean _glewInit_GL_EXT_external_buffer () #ifdef GL_EXT_fog_coord -static GLboolean _glewInit_GL_EXT_fog_coord () +static GLboolean _glewInit_GL_EXT_fog_coord (void) { GLboolean r = GL_FALSE; @@ -14023,7 +14327,7 @@ static GLboolean _glewInit_GL_EXT_fog_coord () #ifdef GL_EXT_fragment_lighting -static GLboolean _glewInit_GL_EXT_fragment_lighting () +static GLboolean _glewInit_GL_EXT_fragment_lighting (void) { GLboolean r = GL_FALSE; @@ -14051,9 +14355,25 @@ static GLboolean _glewInit_GL_EXT_fragment_lighting () #endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_fragment_shading_rate + +static GLboolean _glewInit_GL_EXT_fragment_shading_rate (void) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferShadingRateEXT = (PFNGLFRAMEBUFFERSHADINGRATEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferShadingRateEXT")) == NULL) || r; + r = ((glGetFragmentShadingRatesEXT = (PFNGLGETFRAGMENTSHADINGRATESEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentShadingRatesEXT")) == NULL) || r; + r = ((glShadingRateCombinerOpsEXT = (PFNGLSHADINGRATECOMBINEROPSEXTPROC)glewGetProcAddress((const GLubyte*)"glShadingRateCombinerOpsEXT")) == NULL) || r; + r = ((glShadingRateEXT = (PFNGLSHADINGRATEEXTPROC)glewGetProcAddress((const GLubyte*)"glShadingRateEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_fragment_shading_rate */ + #ifdef GL_EXT_framebuffer_blit -static GLboolean _glewInit_GL_EXT_framebuffer_blit () +static GLboolean _glewInit_GL_EXT_framebuffer_blit (void) { GLboolean r = GL_FALSE; @@ -14064,9 +14384,23 @@ static GLboolean _glewInit_GL_EXT_framebuffer_blit () #endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_blit_layers + +static GLboolean _glewInit_GL_EXT_framebuffer_blit_layers (void) +{ + GLboolean r = GL_FALSE; + + r = ((glBlitFramebufferLayerEXT = (PFNGLBLITFRAMEBUFFERLAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferLayerEXT")) == NULL) || r; + r = ((glBlitFramebufferLayersEXT = (PFNGLBLITFRAMEBUFFERLAYERSEXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferLayersEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_blit_layers */ + #ifdef GL_EXT_framebuffer_multisample -static GLboolean _glewInit_GL_EXT_framebuffer_multisample () +static GLboolean _glewInit_GL_EXT_framebuffer_multisample (void) { GLboolean r = GL_FALSE; @@ -14079,7 +14413,7 @@ static GLboolean _glewInit_GL_EXT_framebuffer_multisample () #ifdef GL_EXT_framebuffer_object -static GLboolean _glewInit_GL_EXT_framebuffer_object () +static GLboolean _glewInit_GL_EXT_framebuffer_object (void) { GLboolean r = GL_FALSE; @@ -14108,7 +14442,7 @@ static GLboolean _glewInit_GL_EXT_framebuffer_object () #ifdef GL_EXT_geometry_shader4 -static GLboolean _glewInit_GL_EXT_geometry_shader4 () +static GLboolean _glewInit_GL_EXT_geometry_shader4 (void) { GLboolean r = GL_FALSE; @@ -14123,7 +14457,7 @@ static GLboolean _glewInit_GL_EXT_geometry_shader4 () #ifdef GL_EXT_gpu_program_parameters -static GLboolean _glewInit_GL_EXT_gpu_program_parameters () +static GLboolean _glewInit_GL_EXT_gpu_program_parameters (void) { GLboolean r = GL_FALSE; @@ -14137,7 +14471,7 @@ static GLboolean _glewInit_GL_EXT_gpu_program_parameters () #ifdef GL_EXT_gpu_shader4 -static GLboolean _glewInit_GL_EXT_gpu_shader4 () +static GLboolean _glewInit_GL_EXT_gpu_shader4 (void) { GLboolean r = GL_FALSE; @@ -14183,7 +14517,7 @@ static GLboolean _glewInit_GL_EXT_gpu_shader4 () #ifdef GL_EXT_histogram -static GLboolean _glewInit_GL_EXT_histogram () +static GLboolean _glewInit_GL_EXT_histogram (void) { GLboolean r = GL_FALSE; @@ -14205,7 +14539,7 @@ static GLboolean _glewInit_GL_EXT_histogram () #ifdef GL_EXT_index_func -static GLboolean _glewInit_GL_EXT_index_func () +static GLboolean _glewInit_GL_EXT_index_func (void) { GLboolean r = GL_FALSE; @@ -14218,7 +14552,7 @@ static GLboolean _glewInit_GL_EXT_index_func () #ifdef GL_EXT_index_material -static GLboolean _glewInit_GL_EXT_index_material () +static GLboolean _glewInit_GL_EXT_index_material (void) { GLboolean r = GL_FALSE; @@ -14231,7 +14565,7 @@ static GLboolean _glewInit_GL_EXT_index_material () #ifdef GL_EXT_instanced_arrays -static GLboolean _glewInit_GL_EXT_instanced_arrays () +static GLboolean _glewInit_GL_EXT_instanced_arrays (void) { GLboolean r = GL_FALSE; @@ -14244,7 +14578,7 @@ static GLboolean _glewInit_GL_EXT_instanced_arrays () #ifdef GL_EXT_light_texture -static GLboolean _glewInit_GL_EXT_light_texture () +static GLboolean _glewInit_GL_EXT_light_texture (void) { GLboolean r = GL_FALSE; @@ -14259,7 +14593,7 @@ static GLboolean _glewInit_GL_EXT_light_texture () #ifdef GL_EXT_map_buffer_range -static GLboolean _glewInit_GL_EXT_map_buffer_range () +static GLboolean _glewInit_GL_EXT_map_buffer_range (void) { GLboolean r = GL_FALSE; @@ -14273,7 +14607,7 @@ static GLboolean _glewInit_GL_EXT_map_buffer_range () #ifdef GL_EXT_memory_object -static GLboolean _glewInit_GL_EXT_memory_object () +static GLboolean _glewInit_GL_EXT_memory_object (void) { GLboolean r = GL_FALSE; @@ -14304,7 +14638,7 @@ static GLboolean _glewInit_GL_EXT_memory_object () #ifdef GL_EXT_memory_object_fd -static GLboolean _glewInit_GL_EXT_memory_object_fd () +static GLboolean _glewInit_GL_EXT_memory_object_fd (void) { GLboolean r = GL_FALSE; @@ -14317,7 +14651,7 @@ static GLboolean _glewInit_GL_EXT_memory_object_fd () #ifdef GL_EXT_memory_object_win32 -static GLboolean _glewInit_GL_EXT_memory_object_win32 () +static GLboolean _glewInit_GL_EXT_memory_object_win32 (void) { GLboolean r = GL_FALSE; @@ -14329,9 +14663,25 @@ static GLboolean _glewInit_GL_EXT_memory_object_win32 () #endif /* GL_EXT_memory_object_win32 */ +#ifdef GL_EXT_mesh_shader + +static GLboolean _glewInit_GL_EXT_mesh_shader (void) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawMeshTasksEXT = (PFNGLDRAWMESHTASKSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksEXT")) == NULL) || r; + r = ((glDrawMeshTasksIndirectEXT = (PFNGLDRAWMESHTASKSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksIndirectEXT")) == NULL) || r; + r = ((glMultiDrawMeshTasksIndirectCountEXT = (PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectCountEXT")) == NULL) || r; + r = ((glMultiDrawMeshTasksIndirectEXT = (PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_mesh_shader */ + #ifdef GL_EXT_multi_draw_arrays -static GLboolean _glewInit_GL_EXT_multi_draw_arrays () +static GLboolean _glewInit_GL_EXT_multi_draw_arrays (void) { GLboolean r = GL_FALSE; @@ -14345,7 +14695,7 @@ static GLboolean _glewInit_GL_EXT_multi_draw_arrays () #ifdef GL_EXT_multi_draw_indirect -static GLboolean _glewInit_GL_EXT_multi_draw_indirect () +static GLboolean _glewInit_GL_EXT_multi_draw_indirect (void) { GLboolean r = GL_FALSE; @@ -14359,7 +14709,7 @@ static GLboolean _glewInit_GL_EXT_multi_draw_indirect () #ifdef GL_EXT_multisample -static GLboolean _glewInit_GL_EXT_multisample () +static GLboolean _glewInit_GL_EXT_multisample (void) { GLboolean r = GL_FALSE; @@ -14373,7 +14723,7 @@ static GLboolean _glewInit_GL_EXT_multisample () #ifdef GL_EXT_multisampled_render_to_texture -static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture () +static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (void) { GLboolean r = GL_FALSE; @@ -14386,7 +14736,7 @@ static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture () #ifdef GL_EXT_multiview_draw_buffers -static GLboolean _glewInit_GL_EXT_multiview_draw_buffers () +static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (void) { GLboolean r = GL_FALSE; @@ -14401,7 +14751,7 @@ static GLboolean _glewInit_GL_EXT_multiview_draw_buffers () #ifdef GL_EXT_paletted_texture -static GLboolean _glewInit_GL_EXT_paletted_texture () +static GLboolean _glewInit_GL_EXT_paletted_texture (void) { GLboolean r = GL_FALSE; @@ -14417,7 +14767,7 @@ static GLboolean _glewInit_GL_EXT_paletted_texture () #ifdef GL_EXT_pixel_transform -static GLboolean _glewInit_GL_EXT_pixel_transform () +static GLboolean _glewInit_GL_EXT_pixel_transform (void) { GLboolean r = GL_FALSE; @@ -14435,7 +14785,7 @@ static GLboolean _glewInit_GL_EXT_pixel_transform () #ifdef GL_EXT_point_parameters -static GLboolean _glewInit_GL_EXT_point_parameters () +static GLboolean _glewInit_GL_EXT_point_parameters (void) { GLboolean r = GL_FALSE; @@ -14449,7 +14799,7 @@ static GLboolean _glewInit_GL_EXT_point_parameters () #ifdef GL_EXT_polygon_offset -static GLboolean _glewInit_GL_EXT_polygon_offset () +static GLboolean _glewInit_GL_EXT_polygon_offset (void) { GLboolean r = GL_FALSE; @@ -14462,7 +14812,7 @@ static GLboolean _glewInit_GL_EXT_polygon_offset () #ifdef GL_EXT_polygon_offset_clamp -static GLboolean _glewInit_GL_EXT_polygon_offset_clamp () +static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (void) { GLboolean r = GL_FALSE; @@ -14475,7 +14825,7 @@ static GLboolean _glewInit_GL_EXT_polygon_offset_clamp () #ifdef GL_EXT_primitive_bounding_box -static GLboolean _glewInit_GL_EXT_primitive_bounding_box () +static GLboolean _glewInit_GL_EXT_primitive_bounding_box (void) { GLboolean r = GL_FALSE; @@ -14488,7 +14838,7 @@ static GLboolean _glewInit_GL_EXT_primitive_bounding_box () #ifdef GL_EXT_provoking_vertex -static GLboolean _glewInit_GL_EXT_provoking_vertex () +static GLboolean _glewInit_GL_EXT_provoking_vertex (void) { GLboolean r = GL_FALSE; @@ -14501,7 +14851,7 @@ static GLboolean _glewInit_GL_EXT_provoking_vertex () #ifdef GL_EXT_raster_multisample -static GLboolean _glewInit_GL_EXT_raster_multisample () +static GLboolean _glewInit_GL_EXT_raster_multisample (void) { GLboolean r = GL_FALSE; @@ -14517,10 +14867,11 @@ static GLboolean _glewInit_GL_EXT_raster_multisample () #ifdef GL_EXT_robustness -static GLboolean _glewInit_GL_EXT_robustness () +static GLboolean _glewInit_GL_EXT_robustness (void) { GLboolean r = GL_FALSE; + r = ((glGetGraphicsResetStatusEXT = (PFNGLGETGRAPHICSRESETSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusEXT")) == NULL) || r; r = ((glGetnUniformfvEXT = (PFNGLGETNUNIFORMFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvEXT")) == NULL) || r; r = ((glGetnUniformivEXT = (PFNGLGETNUNIFORMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivEXT")) == NULL) || r; r = ((glReadnPixelsEXT = (PFNGLREADNPIXELSEXTPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsEXT")) == NULL) || r; @@ -14532,7 +14883,7 @@ static GLboolean _glewInit_GL_EXT_robustness () #ifdef GL_EXT_scene_marker -static GLboolean _glewInit_GL_EXT_scene_marker () +static GLboolean _glewInit_GL_EXT_scene_marker (void) { GLboolean r = GL_FALSE; @@ -14546,7 +14897,7 @@ static GLboolean _glewInit_GL_EXT_scene_marker () #ifdef GL_EXT_secondary_color -static GLboolean _glewInit_GL_EXT_secondary_color () +static GLboolean _glewInit_GL_EXT_secondary_color (void) { GLboolean r = GL_FALSE; @@ -14575,7 +14926,7 @@ static GLboolean _glewInit_GL_EXT_secondary_color () #ifdef GL_EXT_semaphore -static GLboolean _glewInit_GL_EXT_semaphore () +static GLboolean _glewInit_GL_EXT_semaphore (void) { GLboolean r = GL_FALSE; @@ -14594,7 +14945,7 @@ static GLboolean _glewInit_GL_EXT_semaphore () #ifdef GL_EXT_semaphore_fd -static GLboolean _glewInit_GL_EXT_semaphore_fd () +static GLboolean _glewInit_GL_EXT_semaphore_fd (void) { GLboolean r = GL_FALSE; @@ -14607,7 +14958,7 @@ static GLboolean _glewInit_GL_EXT_semaphore_fd () #ifdef GL_EXT_semaphore_win32 -static GLboolean _glewInit_GL_EXT_semaphore_win32 () +static GLboolean _glewInit_GL_EXT_semaphore_win32 (void) { GLboolean r = GL_FALSE; @@ -14621,7 +14972,7 @@ static GLboolean _glewInit_GL_EXT_semaphore_win32 () #ifdef GL_EXT_separate_shader_objects -static GLboolean _glewInit_GL_EXT_separate_shader_objects () +static GLboolean _glewInit_GL_EXT_separate_shader_objects (void) { GLboolean r = GL_FALSE; @@ -14636,7 +14987,7 @@ static GLboolean _glewInit_GL_EXT_separate_shader_objects () #ifdef GL_EXT_shader_framebuffer_fetch -static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch () +static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (void) { GLboolean r = GL_FALSE; @@ -14649,7 +15000,7 @@ static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch () #ifdef GL_EXT_shader_image_load_store -static GLboolean _glewInit_GL_EXT_shader_image_load_store () +static GLboolean _glewInit_GL_EXT_shader_image_load_store (void) { GLboolean r = GL_FALSE; @@ -14663,7 +15014,7 @@ static GLboolean _glewInit_GL_EXT_shader_image_load_store () #ifdef GL_EXT_shader_pixel_local_storage2 -static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 () +static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (void) { GLboolean r = GL_FALSE; @@ -14678,12 +15029,11 @@ static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 () #ifdef GL_EXT_sparse_texture -static GLboolean _glewInit_GL_EXT_sparse_texture () +static GLboolean _glewInit_GL_EXT_sparse_texture (void) { GLboolean r = GL_FALSE; r = ((glTexPageCommitmentEXT = (PFNGLTEXPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentEXT")) == NULL) || r; - r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r; return r; } @@ -14692,7 +15042,7 @@ static GLboolean _glewInit_GL_EXT_sparse_texture () #ifdef GL_EXT_stencil_two_side -static GLboolean _glewInit_GL_EXT_stencil_two_side () +static GLboolean _glewInit_GL_EXT_stencil_two_side (void) { GLboolean r = GL_FALSE; @@ -14705,7 +15055,7 @@ static GLboolean _glewInit_GL_EXT_stencil_two_side () #ifdef GL_EXT_subtexture -static GLboolean _glewInit_GL_EXT_subtexture () +static GLboolean _glewInit_GL_EXT_subtexture (void) { GLboolean r = GL_FALSE; @@ -14720,7 +15070,7 @@ static GLboolean _glewInit_GL_EXT_subtexture () #ifdef GL_EXT_tessellation_point_size -static GLboolean _glewInit_GL_EXT_tessellation_point_size () +static GLboolean _glewInit_GL_EXT_tessellation_point_size (void) { GLboolean r = GL_FALSE; @@ -14733,7 +15083,7 @@ static GLboolean _glewInit_GL_EXT_tessellation_point_size () #ifdef GL_EXT_texture3D -static GLboolean _glewInit_GL_EXT_texture3D () +static GLboolean _glewInit_GL_EXT_texture3D (void) { GLboolean r = GL_FALSE; @@ -14746,7 +15096,7 @@ static GLboolean _glewInit_GL_EXT_texture3D () #ifdef GL_EXT_texture_array -static GLboolean _glewInit_GL_EXT_texture_array () +static GLboolean _glewInit_GL_EXT_texture_array (void) { GLboolean r = GL_FALSE; @@ -14759,7 +15109,7 @@ static GLboolean _glewInit_GL_EXT_texture_array () #ifdef GL_EXT_texture_border_clamp -static GLboolean _glewInit_GL_EXT_texture_border_clamp () +static GLboolean _glewInit_GL_EXT_texture_border_clamp (void) { GLboolean r = GL_FALSE; @@ -14775,7 +15125,7 @@ static GLboolean _glewInit_GL_EXT_texture_border_clamp () #ifdef GL_EXT_texture_buffer_object -static GLboolean _glewInit_GL_EXT_texture_buffer_object () +static GLboolean _glewInit_GL_EXT_texture_buffer_object (void) { GLboolean r = GL_FALSE; @@ -14788,7 +15138,7 @@ static GLboolean _glewInit_GL_EXT_texture_buffer_object () #ifdef GL_EXT_texture_integer -static GLboolean _glewInit_GL_EXT_texture_integer () +static GLboolean _glewInit_GL_EXT_texture_integer (void) { GLboolean r = GL_FALSE; @@ -14806,7 +15156,7 @@ static GLboolean _glewInit_GL_EXT_texture_integer () #ifdef GL_EXT_texture_object -static GLboolean _glewInit_GL_EXT_texture_object () +static GLboolean _glewInit_GL_EXT_texture_object (void) { GLboolean r = GL_FALSE; @@ -14824,7 +15174,7 @@ static GLboolean _glewInit_GL_EXT_texture_object () #ifdef GL_EXT_texture_perturb_normal -static GLboolean _glewInit_GL_EXT_texture_perturb_normal () +static GLboolean _glewInit_GL_EXT_texture_perturb_normal (void) { GLboolean r = GL_FALSE; @@ -14837,7 +15187,7 @@ static GLboolean _glewInit_GL_EXT_texture_perturb_normal () #ifdef GL_EXT_texture_storage -static GLboolean _glewInit_GL_EXT_texture_storage () +static GLboolean _glewInit_GL_EXT_texture_storage (void) { GLboolean r = GL_FALSE; @@ -14853,9 +15203,23 @@ static GLboolean _glewInit_GL_EXT_texture_storage () #endif /* GL_EXT_texture_storage */ +#ifdef GL_EXT_texture_storage_compression + +static GLboolean _glewInit_GL_EXT_texture_storage_compression (void) +{ + GLboolean r = GL_FALSE; + + r = ((glTexStorageAttribs2DEXT = (PFNGLTEXSTORAGEATTRIBS2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageAttribs2DEXT")) == NULL) || r; + r = ((glTexStorageAttribs3DEXT = (PFNGLTEXSTORAGEATTRIBS3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageAttribs3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_storage_compression */ + #ifdef GL_EXT_texture_view -static GLboolean _glewInit_GL_EXT_texture_view () +static GLboolean _glewInit_GL_EXT_texture_view (void) { GLboolean r = GL_FALSE; @@ -14868,7 +15232,7 @@ static GLboolean _glewInit_GL_EXT_texture_view () #ifdef GL_EXT_timer_query -static GLboolean _glewInit_GL_EXT_timer_query () +static GLboolean _glewInit_GL_EXT_timer_query (void) { GLboolean r = GL_FALSE; @@ -14882,7 +15246,7 @@ static GLboolean _glewInit_GL_EXT_timer_query () #ifdef GL_EXT_transform_feedback -static GLboolean _glewInit_GL_EXT_transform_feedback () +static GLboolean _glewInit_GL_EXT_transform_feedback (void) { GLboolean r = GL_FALSE; @@ -14901,7 +15265,7 @@ static GLboolean _glewInit_GL_EXT_transform_feedback () #ifdef GL_EXT_vertex_array -static GLboolean _glewInit_GL_EXT_vertex_array () +static GLboolean _glewInit_GL_EXT_vertex_array (void) { GLboolean r = GL_FALSE; @@ -14921,7 +15285,7 @@ static GLboolean _glewInit_GL_EXT_vertex_array () #ifdef GL_EXT_vertex_array_setXXX -static GLboolean _glewInit_GL_EXT_vertex_array_setXXX () +static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (void) { GLboolean r = GL_FALSE; @@ -14936,7 +15300,7 @@ static GLboolean _glewInit_GL_EXT_vertex_array_setXXX () #ifdef GL_EXT_vertex_attrib_64bit -static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit () +static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (void) { GLboolean r = GL_FALSE; @@ -14959,7 +15323,7 @@ static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit () #ifdef GL_EXT_vertex_shader -static GLboolean _glewInit_GL_EXT_vertex_shader () +static GLboolean _glewInit_GL_EXT_vertex_shader (void) { GLboolean r = GL_FALSE; @@ -15013,7 +15377,7 @@ static GLboolean _glewInit_GL_EXT_vertex_shader () #ifdef GL_EXT_vertex_weighting -static GLboolean _glewInit_GL_EXT_vertex_weighting () +static GLboolean _glewInit_GL_EXT_vertex_weighting (void) { GLboolean r = GL_FALSE; @@ -15028,7 +15392,7 @@ static GLboolean _glewInit_GL_EXT_vertex_weighting () #ifdef GL_EXT_win32_keyed_mutex -static GLboolean _glewInit_GL_EXT_win32_keyed_mutex () +static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (void) { GLboolean r = GL_FALSE; @@ -15042,7 +15406,7 @@ static GLboolean _glewInit_GL_EXT_win32_keyed_mutex () #ifdef GL_EXT_window_rectangles -static GLboolean _glewInit_GL_EXT_window_rectangles () +static GLboolean _glewInit_GL_EXT_window_rectangles (void) { GLboolean r = GL_FALSE; @@ -15055,7 +15419,7 @@ static GLboolean _glewInit_GL_EXT_window_rectangles () #ifdef GL_EXT_x11_sync_object -static GLboolean _glewInit_GL_EXT_x11_sync_object () +static GLboolean _glewInit_GL_EXT_x11_sync_object (void) { GLboolean r = GL_FALSE; @@ -15068,7 +15432,7 @@ static GLboolean _glewInit_GL_EXT_x11_sync_object () #ifdef GL_GREMEDY_frame_terminator -static GLboolean _glewInit_GL_GREMEDY_frame_terminator () +static GLboolean _glewInit_GL_GREMEDY_frame_terminator (void) { GLboolean r = GL_FALSE; @@ -15081,7 +15445,7 @@ static GLboolean _glewInit_GL_GREMEDY_frame_terminator () #ifdef GL_GREMEDY_string_marker -static GLboolean _glewInit_GL_GREMEDY_string_marker () +static GLboolean _glewInit_GL_GREMEDY_string_marker (void) { GLboolean r = GL_FALSE; @@ -15094,7 +15458,7 @@ static GLboolean _glewInit_GL_GREMEDY_string_marker () #ifdef GL_HP_image_transform -static GLboolean _glewInit_GL_HP_image_transform () +static GLboolean _glewInit_GL_HP_image_transform (void) { GLboolean r = GL_FALSE; @@ -15112,7 +15476,7 @@ static GLboolean _glewInit_GL_HP_image_transform () #ifdef GL_IBM_multimode_draw_arrays -static GLboolean _glewInit_GL_IBM_multimode_draw_arrays () +static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (void) { GLboolean r = GL_FALSE; @@ -15126,7 +15490,7 @@ static GLboolean _glewInit_GL_IBM_multimode_draw_arrays () #ifdef GL_IBM_vertex_array_lists -static GLboolean _glewInit_GL_IBM_vertex_array_lists () +static GLboolean _glewInit_GL_IBM_vertex_array_lists (void) { GLboolean r = GL_FALSE; @@ -15146,7 +15510,7 @@ static GLboolean _glewInit_GL_IBM_vertex_array_lists () #ifdef GL_IMG_bindless_texture -static GLboolean _glewInit_GL_IMG_bindless_texture () +static GLboolean _glewInit_GL_IMG_bindless_texture (void) { GLboolean r = GL_FALSE; @@ -15164,7 +15528,7 @@ static GLboolean _glewInit_GL_IMG_bindless_texture () #ifdef GL_IMG_framebuffer_downsample -static GLboolean _glewInit_GL_IMG_framebuffer_downsample () +static GLboolean _glewInit_GL_IMG_framebuffer_downsample (void) { GLboolean r = GL_FALSE; @@ -15178,7 +15542,7 @@ static GLboolean _glewInit_GL_IMG_framebuffer_downsample () #ifdef GL_IMG_multisampled_render_to_texture -static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture () +static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (void) { GLboolean r = GL_FALSE; @@ -15190,9 +15554,22 @@ static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture () #endif /* GL_IMG_multisampled_render_to_texture */ +#ifdef GL_INTEL_framebuffer_CMAA + +static GLboolean _glewInit_GL_INTEL_framebuffer_CMAA (void) +{ + GLboolean r = GL_FALSE; + + r = ((glApplyFramebufferAttachmentCMAAINTEL = (PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC)glewGetProcAddress((const GLubyte*)"glApplyFramebufferAttachmentCMAAINTEL")) == NULL) || r; + + return r; +} + +#endif /* GL_INTEL_framebuffer_CMAA */ + #ifdef GL_INTEL_map_texture -static GLboolean _glewInit_GL_INTEL_map_texture () +static GLboolean _glewInit_GL_INTEL_map_texture (void) { GLboolean r = GL_FALSE; @@ -15207,7 +15584,7 @@ static GLboolean _glewInit_GL_INTEL_map_texture () #ifdef GL_INTEL_parallel_arrays -static GLboolean _glewInit_GL_INTEL_parallel_arrays () +static GLboolean _glewInit_GL_INTEL_parallel_arrays (void) { GLboolean r = GL_FALSE; @@ -15223,7 +15600,7 @@ static GLboolean _glewInit_GL_INTEL_parallel_arrays () #ifdef GL_INTEL_performance_query -static GLboolean _glewInit_GL_INTEL_performance_query () +static GLboolean _glewInit_GL_INTEL_performance_query (void) { GLboolean r = GL_FALSE; @@ -15245,7 +15622,7 @@ static GLboolean _glewInit_GL_INTEL_performance_query () #ifdef GL_INTEL_texture_scissor -static GLboolean _glewInit_GL_INTEL_texture_scissor () +static GLboolean _glewInit_GL_INTEL_texture_scissor (void) { GLboolean r = GL_FALSE; @@ -15259,7 +15636,7 @@ static GLboolean _glewInit_GL_INTEL_texture_scissor () #ifdef GL_KHR_blend_equation_advanced -static GLboolean _glewInit_GL_KHR_blend_equation_advanced () +static GLboolean _glewInit_GL_KHR_blend_equation_advanced (void) { GLboolean r = GL_FALSE; @@ -15272,7 +15649,7 @@ static GLboolean _glewInit_GL_KHR_blend_equation_advanced () #ifdef GL_KHR_debug -static GLboolean _glewInit_GL_KHR_debug () +static GLboolean _glewInit_GL_KHR_debug (void) { GLboolean r = GL_FALSE; @@ -15294,7 +15671,7 @@ static GLboolean _glewInit_GL_KHR_debug () #ifdef GL_KHR_parallel_shader_compile -static GLboolean _glewInit_GL_KHR_parallel_shader_compile () +static GLboolean _glewInit_GL_KHR_parallel_shader_compile (void) { GLboolean r = GL_FALSE; @@ -15307,7 +15684,7 @@ static GLboolean _glewInit_GL_KHR_parallel_shader_compile () #ifdef GL_KHR_robustness -static GLboolean _glewInit_GL_KHR_robustness () +static GLboolean _glewInit_GL_KHR_robustness (void) { GLboolean r = GL_FALSE; @@ -15323,7 +15700,7 @@ static GLboolean _glewInit_GL_KHR_robustness () #ifdef GL_KTX_buffer_region -static GLboolean _glewInit_GL_KTX_buffer_region () +static GLboolean _glewInit_GL_KTX_buffer_region (void) { GLboolean r = GL_FALSE; @@ -15340,7 +15717,7 @@ static GLboolean _glewInit_GL_KTX_buffer_region () #ifdef GL_MESA_framebuffer_flip_y -static GLboolean _glewInit_GL_MESA_framebuffer_flip_y () +static GLboolean _glewInit_GL_MESA_framebuffer_flip_y (void) { GLboolean r = GL_FALSE; @@ -15354,7 +15731,7 @@ static GLboolean _glewInit_GL_MESA_framebuffer_flip_y () #ifdef GL_MESA_resize_buffers -static GLboolean _glewInit_GL_MESA_resize_buffers () +static GLboolean _glewInit_GL_MESA_resize_buffers (void) { GLboolean r = GL_FALSE; @@ -15367,7 +15744,7 @@ static GLboolean _glewInit_GL_MESA_resize_buffers () #ifdef GL_MESA_window_pos -static GLboolean _glewInit_GL_MESA_window_pos () +static GLboolean _glewInit_GL_MESA_window_pos (void) { GLboolean r = GL_FALSE; @@ -15403,7 +15780,7 @@ static GLboolean _glewInit_GL_MESA_window_pos () #ifdef GL_NVX_conditional_render -static GLboolean _glewInit_GL_NVX_conditional_render () +static GLboolean _glewInit_GL_NVX_conditional_render (void) { GLboolean r = GL_FALSE; @@ -15417,7 +15794,7 @@ static GLboolean _glewInit_GL_NVX_conditional_render () #ifdef GL_NVX_gpu_multicast2 -static GLboolean _glewInit_GL_NVX_gpu_multicast2 () +static GLboolean _glewInit_GL_NVX_gpu_multicast2 (void) { GLboolean r = GL_FALSE; @@ -15435,7 +15812,7 @@ static GLboolean _glewInit_GL_NVX_gpu_multicast2 () #ifdef GL_NVX_linked_gpu_multicast -static GLboolean _glewInit_GL_NVX_linked_gpu_multicast () +static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (void) { GLboolean r = GL_FALSE; @@ -15450,11 +15827,12 @@ static GLboolean _glewInit_GL_NVX_linked_gpu_multicast () #ifdef GL_NVX_progress_fence -static GLboolean _glewInit_GL_NVX_progress_fence () +static GLboolean _glewInit_GL_NVX_progress_fence (void) { GLboolean r = GL_FALSE; r = ((glClientWaitSemaphoreui64NVX = (PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSemaphoreui64NVX")) == NULL) || r; + r = ((glCreateProgressFenceNVX = (PFNGLCREATEPROGRESSFENCENVXPROC)glewGetProcAddress((const GLubyte*)"glCreateProgressFenceNVX")) == NULL) || r; r = ((glSignalSemaphoreui64NVX = (PFNGLSIGNALSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glSignalSemaphoreui64NVX")) == NULL) || r; r = ((glWaitSemaphoreui64NVX = (PFNGLWAITSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glWaitSemaphoreui64NVX")) == NULL) || r; @@ -15465,7 +15843,7 @@ static GLboolean _glewInit_GL_NVX_progress_fence () #ifdef GL_NV_3dvision_settings -static GLboolean _glewInit_GL_NV_3dvision_settings () +static GLboolean _glewInit_GL_NV_3dvision_settings (void) { GLboolean r = GL_FALSE; @@ -15479,7 +15857,7 @@ static GLboolean _glewInit_GL_NV_3dvision_settings () #ifdef GL_NV_alpha_to_coverage_dither_control -static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control () +static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control (void) { GLboolean r = GL_FALSE; @@ -15492,7 +15870,7 @@ static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control () #ifdef GL_NV_bindless_multi_draw_indirect -static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect () +static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (void) { GLboolean r = GL_FALSE; @@ -15506,7 +15884,7 @@ static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect () #ifdef GL_NV_bindless_multi_draw_indirect_count -static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count () +static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (void) { GLboolean r = GL_FALSE; @@ -15520,7 +15898,7 @@ static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count () #ifdef GL_NV_bindless_texture -static GLboolean _glewInit_GL_NV_bindless_texture () +static GLboolean _glewInit_GL_NV_bindless_texture (void) { GLboolean r = GL_FALSE; @@ -15545,7 +15923,7 @@ static GLboolean _glewInit_GL_NV_bindless_texture () #ifdef GL_NV_blend_equation_advanced -static GLboolean _glewInit_GL_NV_blend_equation_advanced () +static GLboolean _glewInit_GL_NV_blend_equation_advanced (void) { GLboolean r = GL_FALSE; @@ -15559,7 +15937,7 @@ static GLboolean _glewInit_GL_NV_blend_equation_advanced () #ifdef GL_NV_clip_space_w_scaling -static GLboolean _glewInit_GL_NV_clip_space_w_scaling () +static GLboolean _glewInit_GL_NV_clip_space_w_scaling (void) { GLboolean r = GL_FALSE; @@ -15572,7 +15950,7 @@ static GLboolean _glewInit_GL_NV_clip_space_w_scaling () #ifdef GL_NV_command_list -static GLboolean _glewInit_GL_NV_command_list () +static GLboolean _glewInit_GL_NV_command_list (void) { GLboolean r = GL_FALSE; @@ -15601,7 +15979,7 @@ static GLboolean _glewInit_GL_NV_command_list () #ifdef GL_NV_conditional_render -static GLboolean _glewInit_GL_NV_conditional_render () +static GLboolean _glewInit_GL_NV_conditional_render (void) { GLboolean r = GL_FALSE; @@ -15615,7 +15993,7 @@ static GLboolean _glewInit_GL_NV_conditional_render () #ifdef GL_NV_conservative_raster -static GLboolean _glewInit_GL_NV_conservative_raster () +static GLboolean _glewInit_GL_NV_conservative_raster (void) { GLboolean r = GL_FALSE; @@ -15628,7 +16006,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster () #ifdef GL_NV_conservative_raster_dilate -static GLboolean _glewInit_GL_NV_conservative_raster_dilate () +static GLboolean _glewInit_GL_NV_conservative_raster_dilate (void) { GLboolean r = GL_FALSE; @@ -15641,7 +16019,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster_dilate () #ifdef GL_NV_conservative_raster_pre_snap_triangles -static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles () +static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (void) { GLboolean r = GL_FALSE; @@ -15654,7 +16032,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles () #ifdef GL_NV_copy_buffer -static GLboolean _glewInit_GL_NV_copy_buffer () +static GLboolean _glewInit_GL_NV_copy_buffer (void) { GLboolean r = GL_FALSE; @@ -15667,7 +16045,7 @@ static GLboolean _glewInit_GL_NV_copy_buffer () #ifdef GL_NV_copy_image -static GLboolean _glewInit_GL_NV_copy_image () +static GLboolean _glewInit_GL_NV_copy_image (void) { GLboolean r = GL_FALSE; @@ -15680,7 +16058,7 @@ static GLboolean _glewInit_GL_NV_copy_image () #ifdef GL_NV_depth_buffer_float -static GLboolean _glewInit_GL_NV_depth_buffer_float () +static GLboolean _glewInit_GL_NV_depth_buffer_float (void) { GLboolean r = GL_FALSE; @@ -15695,7 +16073,7 @@ static GLboolean _glewInit_GL_NV_depth_buffer_float () #ifdef GL_NV_draw_buffers -static GLboolean _glewInit_GL_NV_draw_buffers () +static GLboolean _glewInit_GL_NV_draw_buffers (void) { GLboolean r = GL_FALSE; @@ -15708,7 +16086,7 @@ static GLboolean _glewInit_GL_NV_draw_buffers () #ifdef GL_NV_draw_instanced -static GLboolean _glewInit_GL_NV_draw_instanced () +static GLboolean _glewInit_GL_NV_draw_instanced (void) { GLboolean r = GL_FALSE; @@ -15722,7 +16100,7 @@ static GLboolean _glewInit_GL_NV_draw_instanced () #ifdef GL_NV_draw_texture -static GLboolean _glewInit_GL_NV_draw_texture () +static GLboolean _glewInit_GL_NV_draw_texture (void) { GLboolean r = GL_FALSE; @@ -15735,7 +16113,7 @@ static GLboolean _glewInit_GL_NV_draw_texture () #ifdef GL_NV_draw_vulkan_image -static GLboolean _glewInit_GL_NV_draw_vulkan_image () +static GLboolean _glewInit_GL_NV_draw_vulkan_image (void) { GLboolean r = GL_FALSE; @@ -15752,7 +16130,7 @@ static GLboolean _glewInit_GL_NV_draw_vulkan_image () #ifdef GL_NV_evaluators -static GLboolean _glewInit_GL_NV_evaluators () +static GLboolean _glewInit_GL_NV_evaluators (void) { GLboolean r = GL_FALSE; @@ -15773,7 +16151,7 @@ static GLboolean _glewInit_GL_NV_evaluators () #ifdef GL_NV_explicit_multisample -static GLboolean _glewInit_GL_NV_explicit_multisample () +static GLboolean _glewInit_GL_NV_explicit_multisample (void) { GLboolean r = GL_FALSE; @@ -15788,7 +16166,7 @@ static GLboolean _glewInit_GL_NV_explicit_multisample () #ifdef GL_NV_fence -static GLboolean _glewInit_GL_NV_fence () +static GLboolean _glewInit_GL_NV_fence (void) { GLboolean r = GL_FALSE; @@ -15807,7 +16185,7 @@ static GLboolean _glewInit_GL_NV_fence () #ifdef GL_NV_fragment_coverage_to_color -static GLboolean _glewInit_GL_NV_fragment_coverage_to_color () +static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (void) { GLboolean r = GL_FALSE; @@ -15820,7 +16198,7 @@ static GLboolean _glewInit_GL_NV_fragment_coverage_to_color () #ifdef GL_NV_fragment_program -static GLboolean _glewInit_GL_NV_fragment_program () +static GLboolean _glewInit_GL_NV_fragment_program (void) { GLboolean r = GL_FALSE; @@ -15838,7 +16216,7 @@ static GLboolean _glewInit_GL_NV_fragment_program () #ifdef GL_NV_framebuffer_blit -static GLboolean _glewInit_GL_NV_framebuffer_blit () +static GLboolean _glewInit_GL_NV_framebuffer_blit (void) { GLboolean r = GL_FALSE; @@ -15851,7 +16229,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_blit () #ifdef GL_NV_framebuffer_multisample -static GLboolean _glewInit_GL_NV_framebuffer_multisample () +static GLboolean _glewInit_GL_NV_framebuffer_multisample (void) { GLboolean r = GL_FALSE; @@ -15864,7 +16242,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_multisample () #ifdef GL_NV_framebuffer_multisample_coverage -static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage () +static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (void) { GLboolean r = GL_FALSE; @@ -15877,7 +16255,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage () #ifdef GL_NV_geometry_program4 -static GLboolean _glewInit_GL_NV_geometry_program4 () +static GLboolean _glewInit_GL_NV_geometry_program4 (void) { GLboolean r = GL_FALSE; @@ -15890,7 +16268,7 @@ static GLboolean _glewInit_GL_NV_geometry_program4 () #ifdef GL_NV_gpu_multicast -static GLboolean _glewInit_GL_NV_gpu_multicast () +static GLboolean _glewInit_GL_NV_gpu_multicast (void) { GLboolean r = GL_FALSE; @@ -15914,7 +16292,7 @@ static GLboolean _glewInit_GL_NV_gpu_multicast () #ifdef GL_NV_gpu_program4 -static GLboolean _glewInit_GL_NV_gpu_program4 () +static GLboolean _glewInit_GL_NV_gpu_program4 (void) { GLboolean r = GL_FALSE; @@ -15938,7 +16316,7 @@ static GLboolean _glewInit_GL_NV_gpu_program4 () #ifdef GL_NV_gpu_shader5 -static GLboolean _glewInit_GL_NV_gpu_shader5 () +static GLboolean _glewInit_GL_NV_gpu_shader5 (void) { GLboolean r = GL_FALSE; @@ -15984,7 +16362,7 @@ static GLboolean _glewInit_GL_NV_gpu_shader5 () #ifdef GL_NV_half_float -static GLboolean _glewInit_GL_NV_half_float () +static GLboolean _glewInit_GL_NV_half_float (void) { GLboolean r = GL_FALSE; @@ -16042,7 +16420,7 @@ static GLboolean _glewInit_GL_NV_half_float () #ifdef GL_NV_instanced_arrays -static GLboolean _glewInit_GL_NV_instanced_arrays () +static GLboolean _glewInit_GL_NV_instanced_arrays (void) { GLboolean r = GL_FALSE; @@ -16055,7 +16433,7 @@ static GLboolean _glewInit_GL_NV_instanced_arrays () #ifdef GL_NV_internalformat_sample_query -static GLboolean _glewInit_GL_NV_internalformat_sample_query () +static GLboolean _glewInit_GL_NV_internalformat_sample_query (void) { GLboolean r = GL_FALSE; @@ -16068,7 +16446,7 @@ static GLboolean _glewInit_GL_NV_internalformat_sample_query () #ifdef GL_NV_memory_attachment -static GLboolean _glewInit_GL_NV_memory_attachment () +static GLboolean _glewInit_GL_NV_memory_attachment (void) { GLboolean r = GL_FALSE; @@ -16084,9 +16462,25 @@ static GLboolean _glewInit_GL_NV_memory_attachment () #endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_memory_object_sparse + +static GLboolean _glewInit_GL_NV_memory_object_sparse (void) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferPageCommitmentMemNV = (PFNGLBUFFERPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glBufferPageCommitmentMemNV")) == NULL) || r; + r = ((glNamedBufferPageCommitmentMemNV = (PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferPageCommitmentMemNV")) == NULL) || r; + r = ((glTexPageCommitmentMemNV = (PFNGLTEXPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentMemNV")) == NULL) || r; + r = ((glTexturePageCommitmentMemNV = (PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentMemNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_memory_object_sparse */ + #ifdef GL_NV_mesh_shader -static GLboolean _glewInit_GL_NV_mesh_shader () +static GLboolean _glewInit_GL_NV_mesh_shader (void) { GLboolean r = GL_FALSE; @@ -16102,7 +16496,7 @@ static GLboolean _glewInit_GL_NV_mesh_shader () #ifdef GL_NV_non_square_matrices -static GLboolean _glewInit_GL_NV_non_square_matrices () +static GLboolean _glewInit_GL_NV_non_square_matrices (void) { GLboolean r = GL_FALSE; @@ -16120,7 +16514,7 @@ static GLboolean _glewInit_GL_NV_non_square_matrices () #ifdef GL_NV_occlusion_query -static GLboolean _glewInit_GL_NV_occlusion_query () +static GLboolean _glewInit_GL_NV_occlusion_query (void) { GLboolean r = GL_FALSE; @@ -16139,7 +16533,7 @@ static GLboolean _glewInit_GL_NV_occlusion_query () #ifdef GL_NV_parameter_buffer_object -static GLboolean _glewInit_GL_NV_parameter_buffer_object () +static GLboolean _glewInit_GL_NV_parameter_buffer_object (void) { GLboolean r = GL_FALSE; @@ -16154,7 +16548,7 @@ static GLboolean _glewInit_GL_NV_parameter_buffer_object () #ifdef GL_NV_path_rendering -static GLboolean _glewInit_GL_NV_path_rendering () +static GLboolean _glewInit_GL_NV_path_rendering (void) { GLboolean r = GL_FALSE; @@ -16230,7 +16624,7 @@ static GLboolean _glewInit_GL_NV_path_rendering () #ifdef GL_NV_pixel_data_range -static GLboolean _glewInit_GL_NV_pixel_data_range () +static GLboolean _glewInit_GL_NV_pixel_data_range (void) { GLboolean r = GL_FALSE; @@ -16244,7 +16638,7 @@ static GLboolean _glewInit_GL_NV_pixel_data_range () #ifdef GL_NV_point_sprite -static GLboolean _glewInit_GL_NV_point_sprite () +static GLboolean _glewInit_GL_NV_point_sprite (void) { GLboolean r = GL_FALSE; @@ -16258,7 +16652,7 @@ static GLboolean _glewInit_GL_NV_point_sprite () #ifdef GL_NV_polygon_mode -static GLboolean _glewInit_GL_NV_polygon_mode () +static GLboolean _glewInit_GL_NV_polygon_mode (void) { GLboolean r = GL_FALSE; @@ -16271,7 +16665,7 @@ static GLboolean _glewInit_GL_NV_polygon_mode () #ifdef GL_NV_present_video -static GLboolean _glewInit_GL_NV_present_video () +static GLboolean _glewInit_GL_NV_present_video (void) { GLboolean r = GL_FALSE; @@ -16289,7 +16683,7 @@ static GLboolean _glewInit_GL_NV_present_video () #ifdef GL_NV_primitive_restart -static GLboolean _glewInit_GL_NV_primitive_restart () +static GLboolean _glewInit_GL_NV_primitive_restart (void) { GLboolean r = GL_FALSE; @@ -16303,7 +16697,7 @@ static GLboolean _glewInit_GL_NV_primitive_restart () #ifdef GL_NV_read_buffer -static GLboolean _glewInit_GL_NV_read_buffer () +static GLboolean _glewInit_GL_NV_read_buffer (void) { GLboolean r = GL_FALSE; @@ -16316,7 +16710,7 @@ static GLboolean _glewInit_GL_NV_read_buffer () #ifdef GL_NV_register_combiners -static GLboolean _glewInit_GL_NV_register_combiners () +static GLboolean _glewInit_GL_NV_register_combiners (void) { GLboolean r = GL_FALSE; @@ -16341,7 +16735,7 @@ static GLboolean _glewInit_GL_NV_register_combiners () #ifdef GL_NV_register_combiners2 -static GLboolean _glewInit_GL_NV_register_combiners2 () +static GLboolean _glewInit_GL_NV_register_combiners2 (void) { GLboolean r = GL_FALSE; @@ -16355,7 +16749,7 @@ static GLboolean _glewInit_GL_NV_register_combiners2 () #ifdef GL_NV_sample_locations -static GLboolean _glewInit_GL_NV_sample_locations () +static GLboolean _glewInit_GL_NV_sample_locations (void) { GLboolean r = GL_FALSE; @@ -16370,7 +16764,7 @@ static GLboolean _glewInit_GL_NV_sample_locations () #ifdef GL_NV_scissor_exclusive -static GLboolean _glewInit_GL_NV_scissor_exclusive () +static GLboolean _glewInit_GL_NV_scissor_exclusive (void) { GLboolean r = GL_FALSE; @@ -16384,7 +16778,7 @@ static GLboolean _glewInit_GL_NV_scissor_exclusive () #ifdef GL_NV_shader_buffer_load -static GLboolean _glewInit_GL_NV_shader_buffer_load () +static GLboolean _glewInit_GL_NV_shader_buffer_load (void) { GLboolean r = GL_FALSE; @@ -16409,7 +16803,7 @@ static GLboolean _glewInit_GL_NV_shader_buffer_load () #ifdef GL_NV_shading_rate_image -static GLboolean _glewInit_GL_NV_shading_rate_image () +static GLboolean _glewInit_GL_NV_shading_rate_image (void) { GLboolean r = GL_FALSE; @@ -16419,6 +16813,7 @@ static GLboolean _glewInit_GL_NV_shading_rate_image () r = ((glShadingRateImageBarrierNV = (PFNGLSHADINGRATEIMAGEBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImageBarrierNV")) == NULL) || r; r = ((glShadingRateImagePaletteNV = (PFNGLSHADINGRATEIMAGEPALETTENVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImagePaletteNV")) == NULL) || r; r = ((glShadingRateSampleOrderCustomNV = (PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateSampleOrderCustomNV")) == NULL) || r; + r = ((glShadingRateSampleOrderNV = (PFNGLSHADINGRATESAMPLEORDERNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateSampleOrderNV")) == NULL) || r; return r; } @@ -16427,7 +16822,7 @@ static GLboolean _glewInit_GL_NV_shading_rate_image () #ifdef GL_NV_texture_array -static GLboolean _glewInit_GL_NV_texture_array () +static GLboolean _glewInit_GL_NV_texture_array (void) { GLboolean r = GL_FALSE; @@ -16445,7 +16840,7 @@ static GLboolean _glewInit_GL_NV_texture_array () #ifdef GL_NV_texture_barrier -static GLboolean _glewInit_GL_NV_texture_barrier () +static GLboolean _glewInit_GL_NV_texture_barrier (void) { GLboolean r = GL_FALSE; @@ -16458,7 +16853,7 @@ static GLboolean _glewInit_GL_NV_texture_barrier () #ifdef GL_NV_texture_multisample -static GLboolean _glewInit_GL_NV_texture_multisample () +static GLboolean _glewInit_GL_NV_texture_multisample (void) { GLboolean r = GL_FALSE; @@ -16474,9 +16869,24 @@ static GLboolean _glewInit_GL_NV_texture_multisample () #endif /* GL_NV_texture_multisample */ +#ifdef GL_NV_timeline_semaphore + +static GLboolean _glewInit_GL_NV_timeline_semaphore (void) +{ + GLboolean r = GL_FALSE; + + r = ((glCreateSemaphoresNV = (PFNGLCREATESEMAPHORESNVPROC)glewGetProcAddress((const GLubyte*)"glCreateSemaphoresNV")) == NULL) || r; + r = ((glGetSemaphoreParameterivNV = (PFNGLGETSEMAPHOREPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetSemaphoreParameterivNV")) == NULL) || r; + r = ((glSemaphoreParameterivNV = (PFNGLSEMAPHOREPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glSemaphoreParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_timeline_semaphore */ + #ifdef GL_NV_transform_feedback -static GLboolean _glewInit_GL_NV_transform_feedback () +static GLboolean _glewInit_GL_NV_transform_feedback (void) { GLboolean r = GL_FALSE; @@ -16499,7 +16909,7 @@ static GLboolean _glewInit_GL_NV_transform_feedback () #ifdef GL_NV_transform_feedback2 -static GLboolean _glewInit_GL_NV_transform_feedback2 () +static GLboolean _glewInit_GL_NV_transform_feedback2 (void) { GLboolean r = GL_FALSE; @@ -16518,7 +16928,7 @@ static GLboolean _glewInit_GL_NV_transform_feedback2 () #ifdef GL_NV_vdpau_interop -static GLboolean _glewInit_GL_NV_vdpau_interop () +static GLboolean _glewInit_GL_NV_vdpau_interop (void) { GLboolean r = GL_FALSE; @@ -16540,7 +16950,7 @@ static GLboolean _glewInit_GL_NV_vdpau_interop () #ifdef GL_NV_vdpau_interop2 -static GLboolean _glewInit_GL_NV_vdpau_interop2 () +static GLboolean _glewInit_GL_NV_vdpau_interop2 (void) { GLboolean r = GL_FALSE; @@ -16553,7 +16963,7 @@ static GLboolean _glewInit_GL_NV_vdpau_interop2 () #ifdef GL_NV_vertex_array_range -static GLboolean _glewInit_GL_NV_vertex_array_range () +static GLboolean _glewInit_GL_NV_vertex_array_range (void) { GLboolean r = GL_FALSE; @@ -16567,7 +16977,7 @@ static GLboolean _glewInit_GL_NV_vertex_array_range () #ifdef GL_NV_vertex_attrib_integer_64bit -static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit () +static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (void) { GLboolean r = GL_FALSE; @@ -16598,7 +17008,7 @@ static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit () #ifdef GL_NV_vertex_buffer_unified_memory -static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory () +static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (void) { GLboolean r = GL_FALSE; @@ -16622,7 +17032,7 @@ static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory () #ifdef GL_NV_vertex_program -static GLboolean _glewInit_GL_NV_vertex_program () +static GLboolean _glewInit_GL_NV_vertex_program (void) { GLboolean r = GL_FALSE; @@ -16698,7 +17108,7 @@ static GLboolean _glewInit_GL_NV_vertex_program () #ifdef GL_NV_video_capture -static GLboolean _glewInit_GL_NV_video_capture () +static GLboolean _glewInit_GL_NV_video_capture (void) { GLboolean r = GL_FALSE; @@ -16722,7 +17132,7 @@ static GLboolean _glewInit_GL_NV_video_capture () #ifdef GL_NV_viewport_array -static GLboolean _glewInit_GL_NV_viewport_array () +static GLboolean _glewInit_GL_NV_viewport_array (void) { GLboolean r = GL_FALSE; @@ -16746,7 +17156,7 @@ static GLboolean _glewInit_GL_NV_viewport_array () #ifdef GL_NV_viewport_swizzle -static GLboolean _glewInit_GL_NV_viewport_swizzle () +static GLboolean _glewInit_GL_NV_viewport_swizzle (void) { GLboolean r = GL_FALSE; @@ -16759,7 +17169,7 @@ static GLboolean _glewInit_GL_NV_viewport_swizzle () #ifdef GL_OES_EGL_image -static GLboolean _glewInit_GL_OES_EGL_image () +static GLboolean _glewInit_GL_OES_EGL_image (void) { GLboolean r = GL_FALSE; @@ -16773,7 +17183,7 @@ static GLboolean _glewInit_GL_OES_EGL_image () #ifdef GL_OES_blend_equation_separate -static GLboolean _glewInit_GL_OES_blend_equation_separate () +static GLboolean _glewInit_GL_OES_blend_equation_separate (void) { GLboolean r = GL_FALSE; @@ -16786,7 +17196,7 @@ static GLboolean _glewInit_GL_OES_blend_equation_separate () #ifdef GL_OES_blend_func_separate -static GLboolean _glewInit_GL_OES_blend_func_separate () +static GLboolean _glewInit_GL_OES_blend_func_separate (void) { GLboolean r = GL_FALSE; @@ -16799,7 +17209,7 @@ static GLboolean _glewInit_GL_OES_blend_func_separate () #ifdef GL_OES_blend_subtract -static GLboolean _glewInit_GL_OES_blend_subtract () +static GLboolean _glewInit_GL_OES_blend_subtract (void) { GLboolean r = GL_FALSE; @@ -16812,7 +17222,7 @@ static GLboolean _glewInit_GL_OES_blend_subtract () #ifdef GL_OES_copy_image -static GLboolean _glewInit_GL_OES_copy_image () +static GLboolean _glewInit_GL_OES_copy_image (void) { GLboolean r = GL_FALSE; @@ -16825,7 +17235,7 @@ static GLboolean _glewInit_GL_OES_copy_image () #ifdef GL_OES_draw_buffers_indexed -static GLboolean _glewInit_GL_OES_draw_buffers_indexed () +static GLboolean _glewInit_GL_OES_draw_buffers_indexed (void) { GLboolean r = GL_FALSE; @@ -16845,7 +17255,7 @@ static GLboolean _glewInit_GL_OES_draw_buffers_indexed () #ifdef GL_OES_framebuffer_object -static GLboolean _glewInit_GL_OES_framebuffer_object () +static GLboolean _glewInit_GL_OES_framebuffer_object (void) { GLboolean r = GL_FALSE; @@ -16872,7 +17282,7 @@ static GLboolean _glewInit_GL_OES_framebuffer_object () #ifdef GL_OES_get_program_binary -static GLboolean _glewInit_GL_OES_get_program_binary () +static GLboolean _glewInit_GL_OES_get_program_binary (void) { GLboolean r = GL_FALSE; @@ -16886,7 +17296,7 @@ static GLboolean _glewInit_GL_OES_get_program_binary () #ifdef GL_OES_mapbuffer -static GLboolean _glewInit_GL_OES_mapbuffer () +static GLboolean _glewInit_GL_OES_mapbuffer (void) { GLboolean r = GL_FALSE; @@ -16901,11 +17311,12 @@ static GLboolean _glewInit_GL_OES_mapbuffer () #ifdef GL_OES_matrix_palette -static GLboolean _glewInit_GL_OES_matrix_palette () +static GLboolean _glewInit_GL_OES_matrix_palette (void) { GLboolean r = GL_FALSE; r = ((glCurrentPaletteMatrixOES = (PFNGLCURRENTPALETTEMATRIXOESPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixOES")) == NULL) || r; + r = ((glLoadPaletteFromModelViewMatrixOES = (PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC)glewGetProcAddress((const GLubyte*)"glLoadPaletteFromModelViewMatrixOES")) == NULL) || r; r = ((glMatrixIndexPointerOES = (PFNGLMATRIXINDEXPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerOES")) == NULL) || r; r = ((glWeightPointerOES = (PFNGLWEIGHTPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerOES")) == NULL) || r; @@ -16916,7 +17327,7 @@ static GLboolean _glewInit_GL_OES_matrix_palette () #ifdef GL_OES_sample_shading -static GLboolean _glewInit_GL_OES_sample_shading () +static GLboolean _glewInit_GL_OES_sample_shading (void) { GLboolean r = GL_FALSE; @@ -16929,7 +17340,7 @@ static GLboolean _glewInit_GL_OES_sample_shading () #ifdef GL_OES_single_precision -static GLboolean _glewInit_GL_OES_single_precision () +static GLboolean _glewInit_GL_OES_single_precision (void) { GLboolean r = GL_FALSE; @@ -16947,7 +17358,7 @@ static GLboolean _glewInit_GL_OES_single_precision () #ifdef GL_OES_texture_3D -static GLboolean _glewInit_GL_OES_texture_3D () +static GLboolean _glewInit_GL_OES_texture_3D (void) { GLboolean r = GL_FALSE; @@ -16965,7 +17376,7 @@ static GLboolean _glewInit_GL_OES_texture_3D () #ifdef GL_OES_texture_border_clamp -static GLboolean _glewInit_GL_OES_texture_border_clamp () +static GLboolean _glewInit_GL_OES_texture_border_clamp (void) { GLboolean r = GL_FALSE; @@ -16985,7 +17396,7 @@ static GLboolean _glewInit_GL_OES_texture_border_clamp () #ifdef GL_OES_texture_buffer -static GLboolean _glewInit_GL_OES_texture_buffer () +static GLboolean _glewInit_GL_OES_texture_buffer (void) { GLboolean r = GL_FALSE; @@ -16999,7 +17410,7 @@ static GLboolean _glewInit_GL_OES_texture_buffer () #ifdef GL_OES_texture_cube_map -static GLboolean _glewInit_GL_OES_texture_cube_map () +static GLboolean _glewInit_GL_OES_texture_cube_map (void) { GLboolean r = GL_FALSE; @@ -17020,7 +17431,7 @@ static GLboolean _glewInit_GL_OES_texture_cube_map () #ifdef GL_OES_texture_storage_multisample_2d_array -static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array () +static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (void) { GLboolean r = GL_FALSE; @@ -17033,7 +17444,7 @@ static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array () #ifdef GL_OES_texture_view -static GLboolean _glewInit_GL_OES_texture_view () +static GLboolean _glewInit_GL_OES_texture_view (void) { GLboolean r = GL_FALSE; @@ -17046,7 +17457,7 @@ static GLboolean _glewInit_GL_OES_texture_view () #ifdef GL_OES_vertex_array_object -static GLboolean _glewInit_GL_OES_vertex_array_object () +static GLboolean _glewInit_GL_OES_vertex_array_object (void) { GLboolean r = GL_FALSE; @@ -17062,7 +17473,7 @@ static GLboolean _glewInit_GL_OES_vertex_array_object () #ifdef GL_OVR_multiview -static GLboolean _glewInit_GL_OVR_multiview () +static GLboolean _glewInit_GL_OVR_multiview (void) { GLboolean r = GL_FALSE; @@ -17076,7 +17487,7 @@ static GLboolean _glewInit_GL_OVR_multiview () #ifdef GL_OVR_multiview_multisampled_render_to_texture -static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture () +static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (void) { GLboolean r = GL_FALSE; @@ -17089,7 +17500,7 @@ static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture () #ifdef GL_QCOM_alpha_test -static GLboolean _glewInit_GL_QCOM_alpha_test () +static GLboolean _glewInit_GL_QCOM_alpha_test (void) { GLboolean r = GL_FALSE; @@ -17102,7 +17513,7 @@ static GLboolean _glewInit_GL_QCOM_alpha_test () #ifdef GL_QCOM_driver_control -static GLboolean _glewInit_GL_QCOM_driver_control () +static GLboolean _glewInit_GL_QCOM_driver_control (void) { GLboolean r = GL_FALSE; @@ -17118,7 +17529,7 @@ static GLboolean _glewInit_GL_QCOM_driver_control () #ifdef GL_QCOM_extended_get -static GLboolean _glewInit_GL_QCOM_extended_get () +static GLboolean _glewInit_GL_QCOM_extended_get (void) { GLboolean r = GL_FALSE; @@ -17138,7 +17549,7 @@ static GLboolean _glewInit_GL_QCOM_extended_get () #ifdef GL_QCOM_extended_get2 -static GLboolean _glewInit_GL_QCOM_extended_get2 () +static GLboolean _glewInit_GL_QCOM_extended_get2 (void) { GLboolean r = GL_FALSE; @@ -17152,9 +17563,22 @@ static GLboolean _glewInit_GL_QCOM_extended_get2 () #endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_frame_extrapolation + +static GLboolean _glewInit_GL_QCOM_frame_extrapolation (void) +{ + GLboolean r = GL_FALSE; + + r = ((glExtrapolateTex2DQCOM = (PFNGLEXTRAPOLATETEX2DQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtrapolateTex2DQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_frame_extrapolation */ + #ifdef GL_QCOM_framebuffer_foveated -static GLboolean _glewInit_GL_QCOM_framebuffer_foveated () +static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (void) { GLboolean r = GL_FALSE; @@ -17166,9 +17590,23 @@ static GLboolean _glewInit_GL_QCOM_framebuffer_foveated () #endif /* GL_QCOM_framebuffer_foveated */ +#ifdef GL_QCOM_motion_estimation + +static GLboolean _glewInit_GL_QCOM_motion_estimation (void) +{ + GLboolean r = GL_FALSE; + + r = ((glTexEstimateMotionQCOM = (PFNGLTEXESTIMATEMOTIONQCOMPROC)glewGetProcAddress((const GLubyte*)"glTexEstimateMotionQCOM")) == NULL) || r; + r = ((glTexEstimateMotionRegionsQCOM = (PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC)glewGetProcAddress((const GLubyte*)"glTexEstimateMotionRegionsQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_motion_estimation */ + #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent -static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent () +static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (void) { GLboolean r = GL_FALSE; @@ -17179,9 +17617,22 @@ static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent () #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_shading_rate + +static GLboolean _glewInit_GL_QCOM_shading_rate (void) +{ + GLboolean r = GL_FALSE; + + r = ((glShadingRateQCOM = (PFNGLSHADINGRATEQCOMPROC)glewGetProcAddress((const GLubyte*)"glShadingRateQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_shading_rate */ + #ifdef GL_QCOM_texture_foveated -static GLboolean _glewInit_GL_QCOM_texture_foveated () +static GLboolean _glewInit_GL_QCOM_texture_foveated (void) { GLboolean r = GL_FALSE; @@ -17194,7 +17645,7 @@ static GLboolean _glewInit_GL_QCOM_texture_foveated () #ifdef GL_QCOM_tiled_rendering -static GLboolean _glewInit_GL_QCOM_tiled_rendering () +static GLboolean _glewInit_GL_QCOM_tiled_rendering (void) { GLboolean r = GL_FALSE; @@ -17208,7 +17659,7 @@ static GLboolean _glewInit_GL_QCOM_tiled_rendering () #ifdef GL_REGAL_ES1_0_compatibility -static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility () +static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (void) { GLboolean r = GL_FALSE; @@ -17251,7 +17702,7 @@ static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility () #ifdef GL_REGAL_ES1_1_compatibility -static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility () +static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (void) { GLboolean r = GL_FALSE; @@ -17276,7 +17727,7 @@ static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility () #ifdef GL_REGAL_error_string -static GLboolean _glewInit_GL_REGAL_error_string () +static GLboolean _glewInit_GL_REGAL_error_string (void) { GLboolean r = GL_FALSE; @@ -17289,7 +17740,7 @@ static GLboolean _glewInit_GL_REGAL_error_string () #ifdef GL_REGAL_extension_query -static GLboolean _glewInit_GL_REGAL_extension_query () +static GLboolean _glewInit_GL_REGAL_extension_query (void) { GLboolean r = GL_FALSE; @@ -17303,7 +17754,7 @@ static GLboolean _glewInit_GL_REGAL_extension_query () #ifdef GL_REGAL_log -static GLboolean _glewInit_GL_REGAL_log () +static GLboolean _glewInit_GL_REGAL_log (void) { GLboolean r = GL_FALSE; @@ -17316,7 +17767,7 @@ static GLboolean _glewInit_GL_REGAL_log () #ifdef GL_REGAL_proc_address -static GLboolean _glewInit_GL_REGAL_proc_address () +static GLboolean _glewInit_GL_REGAL_proc_address (void) { GLboolean r = GL_FALSE; @@ -17329,7 +17780,7 @@ static GLboolean _glewInit_GL_REGAL_proc_address () #ifdef GL_SGIS_detail_texture -static GLboolean _glewInit_GL_SGIS_detail_texture () +static GLboolean _glewInit_GL_SGIS_detail_texture (void) { GLboolean r = GL_FALSE; @@ -17343,7 +17794,7 @@ static GLboolean _glewInit_GL_SGIS_detail_texture () #ifdef GL_SGIS_fog_function -static GLboolean _glewInit_GL_SGIS_fog_function () +static GLboolean _glewInit_GL_SGIS_fog_function (void) { GLboolean r = GL_FALSE; @@ -17357,7 +17808,7 @@ static GLboolean _glewInit_GL_SGIS_fog_function () #ifdef GL_SGIS_multisample -static GLboolean _glewInit_GL_SGIS_multisample () +static GLboolean _glewInit_GL_SGIS_multisample (void) { GLboolean r = GL_FALSE; @@ -17371,7 +17822,7 @@ static GLboolean _glewInit_GL_SGIS_multisample () #ifdef GL_SGIS_multitexture -static GLboolean _glewInit_GL_SGIS_multitexture () +static GLboolean _glewInit_GL_SGIS_multitexture (void) { GLboolean r = GL_FALSE; @@ -17387,7 +17838,7 @@ static GLboolean _glewInit_GL_SGIS_multitexture () #ifdef GL_SGIS_shared_multisample -static GLboolean _glewInit_GL_SGIS_shared_multisample () +static GLboolean _glewInit_GL_SGIS_shared_multisample (void) { GLboolean r = GL_FALSE; @@ -17400,7 +17851,7 @@ static GLboolean _glewInit_GL_SGIS_shared_multisample () #ifdef GL_SGIS_sharpen_texture -static GLboolean _glewInit_GL_SGIS_sharpen_texture () +static GLboolean _glewInit_GL_SGIS_sharpen_texture (void) { GLboolean r = GL_FALSE; @@ -17414,7 +17865,7 @@ static GLboolean _glewInit_GL_SGIS_sharpen_texture () #ifdef GL_SGIS_texture4D -static GLboolean _glewInit_GL_SGIS_texture4D () +static GLboolean _glewInit_GL_SGIS_texture4D (void) { GLboolean r = GL_FALSE; @@ -17428,7 +17879,7 @@ static GLboolean _glewInit_GL_SGIS_texture4D () #ifdef GL_SGIS_texture_filter4 -static GLboolean _glewInit_GL_SGIS_texture_filter4 () +static GLboolean _glewInit_GL_SGIS_texture_filter4 (void) { GLboolean r = GL_FALSE; @@ -17442,7 +17893,7 @@ static GLboolean _glewInit_GL_SGIS_texture_filter4 () #ifdef GL_SGIX_async -static GLboolean _glewInit_GL_SGIX_async () +static GLboolean _glewInit_GL_SGIX_async (void) { GLboolean r = GL_FALSE; @@ -17460,7 +17911,7 @@ static GLboolean _glewInit_GL_SGIX_async () #ifdef GL_SGIX_datapipe -static GLboolean _glewInit_GL_SGIX_datapipe () +static GLboolean _glewInit_GL_SGIX_datapipe (void) { GLboolean r = GL_FALSE; @@ -17474,7 +17925,7 @@ static GLboolean _glewInit_GL_SGIX_datapipe () #ifdef GL_SGIX_flush_raster -static GLboolean _glewInit_GL_SGIX_flush_raster () +static GLboolean _glewInit_GL_SGIX_flush_raster (void) { GLboolean r = GL_FALSE; @@ -17487,7 +17938,7 @@ static GLboolean _glewInit_GL_SGIX_flush_raster () #ifdef GL_SGIX_fog_layers -static GLboolean _glewInit_GL_SGIX_fog_layers () +static GLboolean _glewInit_GL_SGIX_fog_layers (void) { GLboolean r = GL_FALSE; @@ -17501,7 +17952,7 @@ static GLboolean _glewInit_GL_SGIX_fog_layers () #ifdef GL_SGIX_fog_texture -static GLboolean _glewInit_GL_SGIX_fog_texture () +static GLboolean _glewInit_GL_SGIX_fog_texture (void) { GLboolean r = GL_FALSE; @@ -17514,7 +17965,7 @@ static GLboolean _glewInit_GL_SGIX_fog_texture () #ifdef GL_SGIX_fragment_specular_lighting -static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting () +static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (void) { GLboolean r = GL_FALSE; @@ -17543,7 +17994,7 @@ static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting () #ifdef GL_SGIX_framezoom -static GLboolean _glewInit_GL_SGIX_framezoom () +static GLboolean _glewInit_GL_SGIX_framezoom (void) { GLboolean r = GL_FALSE; @@ -17556,7 +18007,7 @@ static GLboolean _glewInit_GL_SGIX_framezoom () #ifdef GL_SGIX_igloo_interface -static GLboolean _glewInit_GL_SGIX_igloo_interface () +static GLboolean _glewInit_GL_SGIX_igloo_interface (void) { GLboolean r = GL_FALSE; @@ -17569,7 +18020,7 @@ static GLboolean _glewInit_GL_SGIX_igloo_interface () #ifdef GL_SGIX_mpeg1 -static GLboolean _glewInit_GL_SGIX_mpeg1 () +static GLboolean _glewInit_GL_SGIX_mpeg1 (void) { GLboolean r = GL_FALSE; @@ -17592,7 +18043,7 @@ static GLboolean _glewInit_GL_SGIX_mpeg1 () #ifdef GL_SGIX_nonlinear_lighting_pervertex -static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex () +static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (void) { GLboolean r = GL_FALSE; @@ -17608,7 +18059,7 @@ static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex () #ifdef GL_SGIX_pixel_texture -static GLboolean _glewInit_GL_SGIX_pixel_texture () +static GLboolean _glewInit_GL_SGIX_pixel_texture (void) { GLboolean r = GL_FALSE; @@ -17621,7 +18072,7 @@ static GLboolean _glewInit_GL_SGIX_pixel_texture () #ifdef GL_SGIX_polynomial_ffd -static GLboolean _glewInit_GL_SGIX_polynomial_ffd () +static GLboolean _glewInit_GL_SGIX_polynomial_ffd (void) { GLboolean r = GL_FALSE; @@ -17635,7 +18086,7 @@ static GLboolean _glewInit_GL_SGIX_polynomial_ffd () #ifdef GL_SGIX_quad_mesh -static GLboolean _glewInit_GL_SGIX_quad_mesh () +static GLboolean _glewInit_GL_SGIX_quad_mesh (void) { GLboolean r = GL_FALSE; @@ -17649,7 +18100,7 @@ static GLboolean _glewInit_GL_SGIX_quad_mesh () #ifdef GL_SGIX_reference_plane -static GLboolean _glewInit_GL_SGIX_reference_plane () +static GLboolean _glewInit_GL_SGIX_reference_plane (void) { GLboolean r = GL_FALSE; @@ -17662,7 +18113,7 @@ static GLboolean _glewInit_GL_SGIX_reference_plane () #ifdef GL_SGIX_sprite -static GLboolean _glewInit_GL_SGIX_sprite () +static GLboolean _glewInit_GL_SGIX_sprite (void) { GLboolean r = GL_FALSE; @@ -17678,7 +18129,7 @@ static GLboolean _glewInit_GL_SGIX_sprite () #ifdef GL_SGIX_tag_sample_buffer -static GLboolean _glewInit_GL_SGIX_tag_sample_buffer () +static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (void) { GLboolean r = GL_FALSE; @@ -17691,7 +18142,7 @@ static GLboolean _glewInit_GL_SGIX_tag_sample_buffer () #ifdef GL_SGIX_vector_ops -static GLboolean _glewInit_GL_SGIX_vector_ops () +static GLboolean _glewInit_GL_SGIX_vector_ops (void) { GLboolean r = GL_FALSE; @@ -17705,7 +18156,7 @@ static GLboolean _glewInit_GL_SGIX_vector_ops () #ifdef GL_SGIX_vertex_array_object -static GLboolean _glewInit_GL_SGIX_vertex_array_object () +static GLboolean _glewInit_GL_SGIX_vertex_array_object (void) { GLboolean r = GL_FALSE; @@ -17723,7 +18174,7 @@ static GLboolean _glewInit_GL_SGIX_vertex_array_object () #ifdef GL_SGI_color_table -static GLboolean _glewInit_GL_SGI_color_table () +static GLboolean _glewInit_GL_SGI_color_table (void) { GLboolean r = GL_FALSE; @@ -17742,7 +18193,7 @@ static GLboolean _glewInit_GL_SGI_color_table () #ifdef GL_SGI_fft -static GLboolean _glewInit_GL_SGI_fft () +static GLboolean _glewInit_GL_SGI_fft (void) { GLboolean r = GL_FALSE; @@ -17761,7 +18212,7 @@ static GLboolean _glewInit_GL_SGI_fft () #ifdef GL_SUNX_constant_data -static GLboolean _glewInit_GL_SUNX_constant_data () +static GLboolean _glewInit_GL_SUNX_constant_data (void) { GLboolean r = GL_FALSE; @@ -17774,7 +18225,7 @@ static GLboolean _glewInit_GL_SUNX_constant_data () #ifdef GL_SUN_global_alpha -static GLboolean _glewInit_GL_SUN_global_alpha () +static GLboolean _glewInit_GL_SUN_global_alpha (void) { GLboolean r = GL_FALSE; @@ -17794,7 +18245,7 @@ static GLboolean _glewInit_GL_SUN_global_alpha () #ifdef GL_SUN_read_video_pixels -static GLboolean _glewInit_GL_SUN_read_video_pixels () +static GLboolean _glewInit_GL_SUN_read_video_pixels (void) { GLboolean r = GL_FALSE; @@ -17807,7 +18258,7 @@ static GLboolean _glewInit_GL_SUN_read_video_pixels () #ifdef GL_SUN_triangle_list -static GLboolean _glewInit_GL_SUN_triangle_list () +static GLboolean _glewInit_GL_SUN_triangle_list (void) { GLboolean r = GL_FALSE; @@ -17826,7 +18277,7 @@ static GLboolean _glewInit_GL_SUN_triangle_list () #ifdef GL_SUN_vertex -static GLboolean _glewInit_GL_SUN_vertex () +static GLboolean _glewInit_GL_SUN_vertex (void) { GLboolean r = GL_FALSE; @@ -17878,7 +18329,7 @@ static GLboolean _glewInit_GL_SUN_vertex () #ifdef GL_WIN_swap_hint -static GLboolean _glewInit_GL_WIN_swap_hint () +static GLboolean _glewInit_GL_WIN_swap_hint (void) { GLboolean r = GL_FALSE; @@ -17964,7 +18415,7 @@ GLboolean GLEWAPIENTRY glewGetExtension (const char* name) typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGPROC) (GLenum name); typedef void (GLAPIENTRY * PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params); -static GLenum GLEWAPIENTRY glewContextInit () +GLenum GLEWAPIENTRY glewContextInit (void) { PFNGLGETSTRINGPROC getString; const GLubyte* s; @@ -18488,6 +18939,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_ARB_window_pos if (glewExperimental || GLEW_ARB_window_pos) GLEW_ARB_window_pos = !_glewInit_GL_ARB_window_pos(); #endif /* GL_ARB_window_pos */ +#ifdef GL_ARM_shader_core_properties + if (glewExperimental || GLEW_ARM_shader_core_properties) GLEW_ARM_shader_core_properties = !_glewInit_GL_ARM_shader_core_properties(); +#endif /* GL_ARM_shader_core_properties */ #ifdef GL_ATI_draw_buffers if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers(); #endif /* GL_ATI_draw_buffers */ @@ -18620,9 +19074,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_fragment_lighting if (glewExperimental || GLEW_EXT_fragment_lighting) GLEW_EXT_fragment_lighting = !_glewInit_GL_EXT_fragment_lighting(); #endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_fragment_shading_rate + if (glewExperimental || GLEW_EXT_fragment_shading_rate) GLEW_EXT_fragment_shading_rate = !_glewInit_GL_EXT_fragment_shading_rate(); +#endif /* GL_EXT_fragment_shading_rate */ #ifdef GL_EXT_framebuffer_blit if (glewExperimental || GLEW_EXT_framebuffer_blit) GLEW_EXT_framebuffer_blit = !_glewInit_GL_EXT_framebuffer_blit(); #endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_blit_layers + if (glewExperimental || GLEW_EXT_framebuffer_blit_layers) GLEW_EXT_framebuffer_blit_layers = !_glewInit_GL_EXT_framebuffer_blit_layers(); +#endif /* GL_EXT_framebuffer_blit_layers */ #ifdef GL_EXT_framebuffer_multisample if (glewExperimental || GLEW_EXT_framebuffer_multisample) GLEW_EXT_framebuffer_multisample = !_glewInit_GL_EXT_framebuffer_multisample(); #endif /* GL_EXT_framebuffer_multisample */ @@ -18665,6 +19125,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_memory_object_win32 if (glewExperimental || GLEW_EXT_memory_object_win32) GLEW_EXT_memory_object_win32 = !_glewInit_GL_EXT_memory_object_win32(); #endif /* GL_EXT_memory_object_win32 */ +#ifdef GL_EXT_mesh_shader + if (glewExperimental || GLEW_EXT_mesh_shader) GLEW_EXT_mesh_shader = !_glewInit_GL_EXT_mesh_shader(); +#endif /* GL_EXT_mesh_shader */ #ifdef GL_EXT_multi_draw_arrays if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays(); #endif /* GL_EXT_multi_draw_arrays */ @@ -18770,6 +19233,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_texture_storage if (glewExperimental || GLEW_EXT_texture_storage) GLEW_EXT_texture_storage = !_glewInit_GL_EXT_texture_storage(); #endif /* GL_EXT_texture_storage */ +#ifdef GL_EXT_texture_storage_compression + if (glewExperimental || GLEW_EXT_texture_storage_compression) GLEW_EXT_texture_storage_compression = !_glewInit_GL_EXT_texture_storage_compression(); +#endif /* GL_EXT_texture_storage_compression */ #ifdef GL_EXT_texture_view if (glewExperimental || GLEW_EXT_texture_view) GLEW_EXT_texture_view = !_glewInit_GL_EXT_texture_view(); #endif /* GL_EXT_texture_view */ @@ -18827,6 +19293,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_IMG_multisampled_render_to_texture if (glewExperimental || GLEW_IMG_multisampled_render_to_texture) GLEW_IMG_multisampled_render_to_texture = !_glewInit_GL_IMG_multisampled_render_to_texture(); #endif /* GL_IMG_multisampled_render_to_texture */ +#ifdef GL_INTEL_framebuffer_CMAA + if (glewExperimental || GLEW_INTEL_framebuffer_CMAA) GLEW_INTEL_framebuffer_CMAA = !_glewInit_GL_INTEL_framebuffer_CMAA(); +#endif /* GL_INTEL_framebuffer_CMAA */ #ifdef GL_INTEL_map_texture if (glewExperimental || GLEW_INTEL_map_texture) GLEW_INTEL_map_texture = !_glewInit_GL_INTEL_map_texture(); #endif /* GL_INTEL_map_texture */ @@ -18980,6 +19449,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_memory_attachment if (glewExperimental || GLEW_NV_memory_attachment) GLEW_NV_memory_attachment = !_glewInit_GL_NV_memory_attachment(); #endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_memory_object_sparse + if (glewExperimental || GLEW_NV_memory_object_sparse) GLEW_NV_memory_object_sparse = !_glewInit_GL_NV_memory_object_sparse(); +#endif /* GL_NV_memory_object_sparse */ #ifdef GL_NV_mesh_shader if (glewExperimental || GLEW_NV_mesh_shader) GLEW_NV_mesh_shader = !_glewInit_GL_NV_mesh_shader(); #endif /* GL_NV_mesh_shader */ @@ -19040,6 +19512,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_texture_multisample if (glewExperimental || GLEW_NV_texture_multisample) GLEW_NV_texture_multisample = !_glewInit_GL_NV_texture_multisample(); #endif /* GL_NV_texture_multisample */ +#ifdef GL_NV_timeline_semaphore + if (glewExperimental || GLEW_NV_timeline_semaphore) GLEW_NV_timeline_semaphore = !_glewInit_GL_NV_timeline_semaphore(); +#endif /* GL_NV_timeline_semaphore */ #ifdef GL_NV_transform_feedback if (glewExperimental || GLEW_NV_transform_feedback) GLEW_NV_transform_feedback = !_glewInit_GL_NV_transform_feedback(); #endif /* GL_NV_transform_feedback */ @@ -19148,12 +19623,21 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_QCOM_extended_get2 if (glewExperimental || GLEW_QCOM_extended_get2) GLEW_QCOM_extended_get2 = !_glewInit_GL_QCOM_extended_get2(); #endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_frame_extrapolation + if (glewExperimental || GLEW_QCOM_frame_extrapolation) GLEW_QCOM_frame_extrapolation = !_glewInit_GL_QCOM_frame_extrapolation(); +#endif /* GL_QCOM_frame_extrapolation */ #ifdef GL_QCOM_framebuffer_foveated if (glewExperimental || GLEW_QCOM_framebuffer_foveated) GLEW_QCOM_framebuffer_foveated = !_glewInit_GL_QCOM_framebuffer_foveated(); #endif /* GL_QCOM_framebuffer_foveated */ +#ifdef GL_QCOM_motion_estimation + if (glewExperimental || GLEW_QCOM_motion_estimation) GLEW_QCOM_motion_estimation = !_glewInit_GL_QCOM_motion_estimation(); +#endif /* GL_QCOM_motion_estimation */ #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent if (glewExperimental || GLEW_QCOM_shader_framebuffer_fetch_noncoherent) GLEW_QCOM_shader_framebuffer_fetch_noncoherent = !_glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent(); #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_shading_rate + if (glewExperimental || GLEW_QCOM_shading_rate) GLEW_QCOM_shading_rate = !_glewInit_GL_QCOM_shading_rate(); +#endif /* GL_QCOM_shading_rate */ #ifdef GL_QCOM_texture_foveated if (glewExperimental || GLEW_QCOM_texture_foveated) GLEW_QCOM_texture_foveated = !_glewInit_GL_QCOM_texture_foveated(); #endif /* GL_QCOM_texture_foveated */ @@ -19367,6 +19851,8 @@ PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROID = NULL; PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE = NULL; +PFNEGLGETMSCRATEANGLEPROC __eglewGetMscRateANGLE = NULL; + PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT = NULL; PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT = NULL; @@ -19379,10 +19865,14 @@ PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEXT = NULL; PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT = NULL; +PFNEGLQUERYDEVICEBINARYEXTPROC __eglewQueryDeviceBinaryEXT = NULL; + PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT = NULL; PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT = NULL; PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT = NULL; +PFNEGLDESTROYDISPLAYEXTPROC __eglewDestroyDisplayEXT = NULL; + PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT = NULL; PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT = NULL; @@ -19401,6 +19891,8 @@ PFNEGLGETPLATFORMDISPLAYEXTPROC __eglewGetPlatformDisplayEXT = NULL; PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT = NULL; +PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC __eglewQuerySupportedCompressionRatesEXT = NULL; + PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT = NULL; PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT = NULL; @@ -19477,6 +19969,11 @@ PFNEGLQUERYNATIVEWINDOWNVPROC __eglewQueryNativeWindowNV = NULL; PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV = NULL; +PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC __eglewQueryStreamConsumerEventNV = NULL; +PFNEGLSTREAMACQUIREIMAGENVPROC __eglewStreamAcquireImageNV = NULL; +PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC __eglewStreamImageConsumerConnectNV = NULL; +PFNEGLSTREAMRELEASEIMAGENVPROC __eglewStreamReleaseImageNV = NULL; + PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV = NULL; PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV = NULL; @@ -19521,10 +20018,12 @@ GLboolean __EGLEW_ANDROID_image_native_buffer = GL_FALSE; GLboolean __EGLEW_ANDROID_native_fence_sync = GL_FALSE; GLboolean __EGLEW_ANDROID_presentation_time = GL_FALSE; GLboolean __EGLEW_ANDROID_recordable = GL_FALSE; +GLboolean __EGLEW_ANDROID_telemetry_hint = GL_FALSE; GLboolean __EGLEW_ANGLE_d3d_share_handle_client_buffer = GL_FALSE; GLboolean __EGLEW_ANGLE_device_d3d = GL_FALSE; GLboolean __EGLEW_ANGLE_query_surface_pointer = GL_FALSE; GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = GL_FALSE; +GLboolean __EGLEW_ANGLE_sync_control_rate = GL_FALSE; GLboolean __EGLEW_ANGLE_window_fixed_size = GL_FALSE; GLboolean __EGLEW_ARM_image_format = GL_FALSE; GLboolean __EGLEW_ARM_implicit_external_sync = GL_FALSE; @@ -19534,12 +20033,19 @@ GLboolean __EGLEW_EXT_buffer_age = GL_FALSE; GLboolean __EGLEW_EXT_client_extensions = GL_FALSE; GLboolean __EGLEW_EXT_client_sync = GL_FALSE; GLboolean __EGLEW_EXT_compositor = GL_FALSE; +GLboolean __EGLEW_EXT_config_select_group = GL_FALSE; GLboolean __EGLEW_EXT_create_context_robustness = GL_FALSE; GLboolean __EGLEW_EXT_device_base = GL_FALSE; GLboolean __EGLEW_EXT_device_drm = GL_FALSE; +GLboolean __EGLEW_EXT_device_drm_render_node = GL_FALSE; GLboolean __EGLEW_EXT_device_enumeration = GL_FALSE; GLboolean __EGLEW_EXT_device_openwf = GL_FALSE; +GLboolean __EGLEW_EXT_device_persistent_id = GL_FALSE; GLboolean __EGLEW_EXT_device_query = GL_FALSE; +GLboolean __EGLEW_EXT_device_query_name = GL_FALSE; +GLboolean __EGLEW_EXT_display_alloc = GL_FALSE; +GLboolean __EGLEW_EXT_explicit_device = GL_FALSE; +GLboolean __EGLEW_EXT_gl_colorspace_bt2020_hlg = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_display_p3 = GL_FALSE; @@ -19560,11 +20066,15 @@ GLboolean __EGLEW_EXT_platform_base = GL_FALSE; GLboolean __EGLEW_EXT_platform_device = GL_FALSE; GLboolean __EGLEW_EXT_platform_wayland = GL_FALSE; GLboolean __EGLEW_EXT_platform_x11 = GL_FALSE; +GLboolean __EGLEW_EXT_platform_xcb = GL_FALSE; +GLboolean __EGLEW_EXT_present_opaque = GL_FALSE; GLboolean __EGLEW_EXT_protected_content = GL_FALSE; GLboolean __EGLEW_EXT_protected_surface = GL_FALSE; +GLboolean __EGLEW_EXT_query_reset_notification_strategy = GL_FALSE; GLboolean __EGLEW_EXT_stream_consumer_egloutput = GL_FALSE; GLboolean __EGLEW_EXT_surface_CTA861_3_metadata = GL_FALSE; GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata = GL_FALSE; +GLboolean __EGLEW_EXT_surface_compression = GL_FALSE; GLboolean __EGLEW_EXT_swap_buffers_with_damage = GL_FALSE; GLboolean __EGLEW_EXT_sync_reuse = GL_FALSE; GLboolean __EGLEW_EXT_yuv_surface = GL_FALSE; @@ -19633,6 +20143,8 @@ GLboolean __EGLEW_NV_post_convert_rounding = GL_FALSE; GLboolean __EGLEW_NV_post_sub_buffer = GL_FALSE; GLboolean __EGLEW_NV_quadruple_buffer = GL_FALSE; GLboolean __EGLEW_NV_robustness_video_memory_purge = GL_FALSE; +GLboolean __EGLEW_NV_stream_consumer_eglimage = GL_FALSE; +GLboolean __EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib = GL_FALSE; GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv = GL_FALSE; GLboolean __EGLEW_NV_stream_cross_display = GL_FALSE; GLboolean __EGLEW_NV_stream_cross_object = GL_FALSE; @@ -19655,13 +20167,15 @@ GLboolean __EGLEW_NV_stream_sync = GL_FALSE; GLboolean __EGLEW_NV_sync = GL_FALSE; GLboolean __EGLEW_NV_system_time = GL_FALSE; GLboolean __EGLEW_NV_triple_buffer = GL_FALSE; +GLboolean __EGLEW_QNX_image_native_buffer = GL_FALSE; +GLboolean __EGLEW_QNX_platform_screen = GL_FALSE; GLboolean __EGLEW_TIZEN_image_native_buffer = GL_FALSE; GLboolean __EGLEW_TIZEN_image_native_surface = GL_FALSE; GLboolean __EGLEW_WL_bind_wayland_display = GL_FALSE; GLboolean __EGLEW_WL_create_wayland_buffer_from_image = GL_FALSE; #ifdef EGL_VERSION_1_0 -static GLboolean _glewInit_EGL_VERSION_1_0 () +static GLboolean _glewInit_EGL_VERSION_1_0 (void) { GLboolean r = GL_FALSE; @@ -19696,7 +20210,7 @@ static GLboolean _glewInit_EGL_VERSION_1_0 () #ifdef EGL_VERSION_1_1 -static GLboolean _glewInit_EGL_VERSION_1_1 () +static GLboolean _glewInit_EGL_VERSION_1_1 (void) { GLboolean r = GL_FALSE; @@ -19712,7 +20226,7 @@ static GLboolean _glewInit_EGL_VERSION_1_1 () #ifdef EGL_VERSION_1_2 -static GLboolean _glewInit_EGL_VERSION_1_2 () +static GLboolean _glewInit_EGL_VERSION_1_2 (void) { GLboolean r = GL_FALSE; @@ -19729,7 +20243,7 @@ static GLboolean _glewInit_EGL_VERSION_1_2 () #ifdef EGL_VERSION_1_4 -static GLboolean _glewInit_EGL_VERSION_1_4 () +static GLboolean _glewInit_EGL_VERSION_1_4 (void) { GLboolean r = GL_FALSE; @@ -19742,7 +20256,7 @@ static GLboolean _glewInit_EGL_VERSION_1_4 () #ifdef EGL_VERSION_1_5 -static GLboolean _glewInit_EGL_VERSION_1_5 () +static GLboolean _glewInit_EGL_VERSION_1_5 (void) { GLboolean r = GL_FALSE; @@ -19764,7 +20278,7 @@ static GLboolean _glewInit_EGL_VERSION_1_5 () #ifdef EGL_ANDROID_blob_cache -static GLboolean _glewInit_EGL_ANDROID_blob_cache () +static GLboolean _glewInit_EGL_ANDROID_blob_cache (void) { GLboolean r = GL_FALSE; @@ -19777,7 +20291,7 @@ static GLboolean _glewInit_EGL_ANDROID_blob_cache () #ifdef EGL_ANDROID_create_native_client_buffer -static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer () +static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer (void) { GLboolean r = GL_FALSE; @@ -19790,7 +20304,7 @@ static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer () #ifdef EGL_ANDROID_get_frame_timestamps -static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps () +static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps (void) { GLboolean r = GL_FALSE; @@ -19807,7 +20321,7 @@ static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps () #ifdef EGL_ANDROID_get_native_client_buffer -static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer () +static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer (void) { GLboolean r = GL_FALSE; @@ -19820,7 +20334,7 @@ static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer () #ifdef EGL_ANDROID_native_fence_sync -static GLboolean _glewInit_EGL_ANDROID_native_fence_sync () +static GLboolean _glewInit_EGL_ANDROID_native_fence_sync (void) { GLboolean r = GL_FALSE; @@ -19833,7 +20347,7 @@ static GLboolean _glewInit_EGL_ANDROID_native_fence_sync () #ifdef EGL_ANDROID_presentation_time -static GLboolean _glewInit_EGL_ANDROID_presentation_time () +static GLboolean _glewInit_EGL_ANDROID_presentation_time (void) { GLboolean r = GL_FALSE; @@ -19846,7 +20360,7 @@ static GLboolean _glewInit_EGL_ANDROID_presentation_time () #ifdef EGL_ANGLE_query_surface_pointer -static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer () +static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer (void) { GLboolean r = GL_FALSE; @@ -19857,9 +20371,22 @@ static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer () #endif /* EGL_ANGLE_query_surface_pointer */ +#ifdef EGL_ANGLE_sync_control_rate + +static GLboolean _glewInit_EGL_ANGLE_sync_control_rate (void) +{ + GLboolean r = GL_FALSE; + + r = ((eglGetMscRateANGLE = (PFNEGLGETMSCRATEANGLEPROC)glewGetProcAddress((const GLubyte*)"eglGetMscRateANGLE")) == NULL) || r; + + return r; +} + +#endif /* EGL_ANGLE_sync_control_rate */ + #ifdef EGL_EXT_client_sync -static GLboolean _glewInit_EGL_EXT_client_sync () +static GLboolean _glewInit_EGL_EXT_client_sync (void) { GLboolean r = GL_FALSE; @@ -19872,7 +20399,7 @@ static GLboolean _glewInit_EGL_EXT_client_sync () #ifdef EGL_EXT_compositor -static GLboolean _glewInit_EGL_EXT_compositor () +static GLboolean _glewInit_EGL_EXT_compositor (void) { GLboolean r = GL_FALSE; @@ -19891,7 +20418,7 @@ static GLboolean _glewInit_EGL_EXT_compositor () #ifdef EGL_EXT_device_enumeration -static GLboolean _glewInit_EGL_EXT_device_enumeration () +static GLboolean _glewInit_EGL_EXT_device_enumeration (void) { GLboolean r = GL_FALSE; @@ -19902,9 +20429,22 @@ static GLboolean _glewInit_EGL_EXT_device_enumeration () #endif /* EGL_EXT_device_enumeration */ +#ifdef EGL_EXT_device_persistent_id + +static GLboolean _glewInit_EGL_EXT_device_persistent_id (void) +{ + GLboolean r = GL_FALSE; + + r = ((eglQueryDeviceBinaryEXT = (PFNEGLQUERYDEVICEBINARYEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDeviceBinaryEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_device_persistent_id */ + #ifdef EGL_EXT_device_query -static GLboolean _glewInit_EGL_EXT_device_query () +static GLboolean _glewInit_EGL_EXT_device_query (void) { GLboolean r = GL_FALSE; @@ -19917,9 +20457,22 @@ static GLboolean _glewInit_EGL_EXT_device_query () #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_display_alloc + +static GLboolean _glewInit_EGL_EXT_display_alloc (void) +{ + GLboolean r = GL_FALSE; + + r = ((eglDestroyDisplayEXT = (PFNEGLDESTROYDISPLAYEXTPROC)glewGetProcAddress((const GLubyte*)"eglDestroyDisplayEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_display_alloc */ + #ifdef EGL_EXT_image_dma_buf_import_modifiers -static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers () +static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers (void) { GLboolean r = GL_FALSE; @@ -19933,7 +20486,7 @@ static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers () #ifdef EGL_EXT_output_base -static GLboolean _glewInit_EGL_EXT_output_base () +static GLboolean _glewInit_EGL_EXT_output_base (void) { GLboolean r = GL_FALSE; @@ -19953,7 +20506,7 @@ static GLboolean _glewInit_EGL_EXT_output_base () #ifdef EGL_EXT_platform_base -static GLboolean _glewInit_EGL_EXT_platform_base () +static GLboolean _glewInit_EGL_EXT_platform_base (void) { GLboolean r = GL_FALSE; @@ -19968,7 +20521,7 @@ static GLboolean _glewInit_EGL_EXT_platform_base () #ifdef EGL_EXT_stream_consumer_egloutput -static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput () +static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput (void) { GLboolean r = GL_FALSE; @@ -19979,9 +20532,22 @@ static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput () #endif /* EGL_EXT_stream_consumer_egloutput */ +#ifdef EGL_EXT_surface_compression + +static GLboolean _glewInit_EGL_EXT_surface_compression (void) +{ + GLboolean r = GL_FALSE; + + r = ((eglQuerySupportedCompressionRatesEXT = (PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC)glewGetProcAddress((const GLubyte*)"eglQuerySupportedCompressionRatesEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_surface_compression */ + #ifdef EGL_EXT_swap_buffers_with_damage -static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage () +static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage (void) { GLboolean r = GL_FALSE; @@ -19994,7 +20560,7 @@ static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage () #ifdef EGL_EXT_sync_reuse -static GLboolean _glewInit_EGL_EXT_sync_reuse () +static GLboolean _glewInit_EGL_EXT_sync_reuse (void) { GLboolean r = GL_FALSE; @@ -20007,7 +20573,7 @@ static GLboolean _glewInit_EGL_EXT_sync_reuse () #ifdef EGL_HI_clientpixmap -static GLboolean _glewInit_EGL_HI_clientpixmap () +static GLboolean _glewInit_EGL_HI_clientpixmap (void) { GLboolean r = GL_FALSE; @@ -20020,7 +20586,7 @@ static GLboolean _glewInit_EGL_HI_clientpixmap () #ifdef EGL_KHR_cl_event2 -static GLboolean _glewInit_EGL_KHR_cl_event2 () +static GLboolean _glewInit_EGL_KHR_cl_event2 (void) { GLboolean r = GL_FALSE; @@ -20033,7 +20599,7 @@ static GLboolean _glewInit_EGL_KHR_cl_event2 () #ifdef EGL_KHR_debug -static GLboolean _glewInit_EGL_KHR_debug () +static GLboolean _glewInit_EGL_KHR_debug (void) { GLboolean r = GL_FALSE; @@ -20048,7 +20614,7 @@ static GLboolean _glewInit_EGL_KHR_debug () #ifdef EGL_KHR_display_reference -static GLboolean _glewInit_EGL_KHR_display_reference () +static GLboolean _glewInit_EGL_KHR_display_reference (void) { GLboolean r = GL_FALSE; @@ -20061,7 +20627,7 @@ static GLboolean _glewInit_EGL_KHR_display_reference () #ifdef EGL_KHR_image -static GLboolean _glewInit_EGL_KHR_image () +static GLboolean _glewInit_EGL_KHR_image (void) { GLboolean r = GL_FALSE; @@ -20075,7 +20641,7 @@ static GLboolean _glewInit_EGL_KHR_image () #ifdef EGL_KHR_lock_surface -static GLboolean _glewInit_EGL_KHR_lock_surface () +static GLboolean _glewInit_EGL_KHR_lock_surface (void) { GLboolean r = GL_FALSE; @@ -20089,7 +20655,7 @@ static GLboolean _glewInit_EGL_KHR_lock_surface () #ifdef EGL_KHR_lock_surface3 -static GLboolean _glewInit_EGL_KHR_lock_surface3 () +static GLboolean _glewInit_EGL_KHR_lock_surface3 (void) { GLboolean r = GL_FALSE; @@ -20102,7 +20668,7 @@ static GLboolean _glewInit_EGL_KHR_lock_surface3 () #ifdef EGL_KHR_partial_update -static GLboolean _glewInit_EGL_KHR_partial_update () +static GLboolean _glewInit_EGL_KHR_partial_update (void) { GLboolean r = GL_FALSE; @@ -20115,7 +20681,7 @@ static GLboolean _glewInit_EGL_KHR_partial_update () #ifdef EGL_KHR_reusable_sync -static GLboolean _glewInit_EGL_KHR_reusable_sync () +static GLboolean _glewInit_EGL_KHR_reusable_sync (void) { GLboolean r = GL_FALSE; @@ -20132,7 +20698,7 @@ static GLboolean _glewInit_EGL_KHR_reusable_sync () #ifdef EGL_KHR_stream -static GLboolean _glewInit_EGL_KHR_stream () +static GLboolean _glewInit_EGL_KHR_stream (void) { GLboolean r = GL_FALSE; @@ -20149,7 +20715,7 @@ static GLboolean _glewInit_EGL_KHR_stream () #ifdef EGL_KHR_stream_attrib -static GLboolean _glewInit_EGL_KHR_stream_attrib () +static GLboolean _glewInit_EGL_KHR_stream_attrib (void) { GLboolean r = GL_FALSE; @@ -20166,7 +20732,7 @@ static GLboolean _glewInit_EGL_KHR_stream_attrib () #ifdef EGL_KHR_stream_consumer_gltexture -static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture () +static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture (void) { GLboolean r = GL_FALSE; @@ -20181,7 +20747,7 @@ static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture () #ifdef EGL_KHR_stream_cross_process_fd -static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd () +static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd (void) { GLboolean r = GL_FALSE; @@ -20195,7 +20761,7 @@ static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd () #ifdef EGL_KHR_stream_fifo -static GLboolean _glewInit_EGL_KHR_stream_fifo () +static GLboolean _glewInit_EGL_KHR_stream_fifo (void) { GLboolean r = GL_FALSE; @@ -20208,7 +20774,7 @@ static GLboolean _glewInit_EGL_KHR_stream_fifo () #ifdef EGL_KHR_stream_producer_eglsurface -static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface () +static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface (void) { GLboolean r = GL_FALSE; @@ -20221,7 +20787,7 @@ static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface () #ifdef EGL_KHR_swap_buffers_with_damage -static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage () +static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage (void) { GLboolean r = GL_FALSE; @@ -20234,7 +20800,7 @@ static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage () #ifdef EGL_KHR_wait_sync -static GLboolean _glewInit_EGL_KHR_wait_sync () +static GLboolean _glewInit_EGL_KHR_wait_sync (void) { GLboolean r = GL_FALSE; @@ -20247,7 +20813,7 @@ static GLboolean _glewInit_EGL_KHR_wait_sync () #ifdef EGL_MESA_drm_image -static GLboolean _glewInit_EGL_MESA_drm_image () +static GLboolean _glewInit_EGL_MESA_drm_image (void) { GLboolean r = GL_FALSE; @@ -20261,7 +20827,7 @@ static GLboolean _glewInit_EGL_MESA_drm_image () #ifdef EGL_MESA_image_dma_buf_export -static GLboolean _glewInit_EGL_MESA_image_dma_buf_export () +static GLboolean _glewInit_EGL_MESA_image_dma_buf_export (void) { GLboolean r = GL_FALSE; @@ -20275,7 +20841,7 @@ static GLboolean _glewInit_EGL_MESA_image_dma_buf_export () #ifdef EGL_MESA_query_driver -static GLboolean _glewInit_EGL_MESA_query_driver () +static GLboolean _glewInit_EGL_MESA_query_driver (void) { GLboolean r = GL_FALSE; @@ -20289,7 +20855,7 @@ static GLboolean _glewInit_EGL_MESA_query_driver () #ifdef EGL_NOK_swap_region -static GLboolean _glewInit_EGL_NOK_swap_region () +static GLboolean _glewInit_EGL_NOK_swap_region (void) { GLboolean r = GL_FALSE; @@ -20302,7 +20868,7 @@ static GLboolean _glewInit_EGL_NOK_swap_region () #ifdef EGL_NOK_swap_region2 -static GLboolean _glewInit_EGL_NOK_swap_region2 () +static GLboolean _glewInit_EGL_NOK_swap_region2 (void) { GLboolean r = GL_FALSE; @@ -20315,7 +20881,7 @@ static GLboolean _glewInit_EGL_NOK_swap_region2 () #ifdef EGL_NV_native_query -static GLboolean _glewInit_EGL_NV_native_query () +static GLboolean _glewInit_EGL_NV_native_query (void) { GLboolean r = GL_FALSE; @@ -20330,7 +20896,7 @@ static GLboolean _glewInit_EGL_NV_native_query () #ifdef EGL_NV_post_sub_buffer -static GLboolean _glewInit_EGL_NV_post_sub_buffer () +static GLboolean _glewInit_EGL_NV_post_sub_buffer (void) { GLboolean r = GL_FALSE; @@ -20341,9 +20907,25 @@ static GLboolean _glewInit_EGL_NV_post_sub_buffer () #endif /* EGL_NV_post_sub_buffer */ +#ifdef EGL_NV_stream_consumer_eglimage + +static GLboolean _glewInit_EGL_NV_stream_consumer_eglimage (void) +{ + GLboolean r = GL_FALSE; + + r = ((eglQueryStreamConsumerEventNV = (PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamConsumerEventNV")) == NULL) || r; + r = ((eglStreamAcquireImageNV = (PFNEGLSTREAMACQUIREIMAGENVPROC)glewGetProcAddress((const GLubyte*)"eglStreamAcquireImageNV")) == NULL) || r; + r = ((eglStreamImageConsumerConnectNV = (PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC)glewGetProcAddress((const GLubyte*)"eglStreamImageConsumerConnectNV")) == NULL) || r; + r = ((eglStreamReleaseImageNV = (PFNEGLSTREAMRELEASEIMAGENVPROC)glewGetProcAddress((const GLubyte*)"eglStreamReleaseImageNV")) == NULL) || r; + + return r; +} + +#endif /* EGL_NV_stream_consumer_eglimage */ + #ifdef EGL_NV_stream_consumer_gltexture_yuv -static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv () +static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv (void) { GLboolean r = GL_FALSE; @@ -20356,7 +20938,7 @@ static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv () #ifdef EGL_NV_stream_flush -static GLboolean _glewInit_EGL_NV_stream_flush () +static GLboolean _glewInit_EGL_NV_stream_flush (void) { GLboolean r = GL_FALSE; @@ -20369,7 +20951,7 @@ static GLboolean _glewInit_EGL_NV_stream_flush () #ifdef EGL_NV_stream_metadata -static GLboolean _glewInit_EGL_NV_stream_metadata () +static GLboolean _glewInit_EGL_NV_stream_metadata (void) { GLboolean r = GL_FALSE; @@ -20384,7 +20966,7 @@ static GLboolean _glewInit_EGL_NV_stream_metadata () #ifdef EGL_NV_stream_reset -static GLboolean _glewInit_EGL_NV_stream_reset () +static GLboolean _glewInit_EGL_NV_stream_reset (void) { GLboolean r = GL_FALSE; @@ -20397,7 +20979,7 @@ static GLboolean _glewInit_EGL_NV_stream_reset () #ifdef EGL_NV_stream_sync -static GLboolean _glewInit_EGL_NV_stream_sync () +static GLboolean _glewInit_EGL_NV_stream_sync (void) { GLboolean r = GL_FALSE; @@ -20410,7 +20992,7 @@ static GLboolean _glewInit_EGL_NV_stream_sync () #ifdef EGL_NV_sync -static GLboolean _glewInit_EGL_NV_sync () +static GLboolean _glewInit_EGL_NV_sync (void) { GLboolean r = GL_FALSE; @@ -20428,7 +21010,7 @@ static GLboolean _glewInit_EGL_NV_sync () #ifdef EGL_NV_system_time -static GLboolean _glewInit_EGL_NV_system_time () +static GLboolean _glewInit_EGL_NV_system_time (void) { GLboolean r = GL_FALSE; @@ -20442,7 +21024,7 @@ static GLboolean _glewInit_EGL_NV_system_time () #ifdef EGL_WL_bind_wayland_display -static GLboolean _glewInit_EGL_WL_bind_wayland_display () +static GLboolean _glewInit_EGL_WL_bind_wayland_display (void) { GLboolean r = GL_FALSE; @@ -20457,7 +21039,7 @@ static GLboolean _glewInit_EGL_WL_bind_wayland_display () #ifdef EGL_WL_create_wayland_buffer_from_image -static GLboolean _glewInit_EGL_WL_create_wayland_buffer_from_image () +static GLboolean _glewInit_EGL_WL_create_wayland_buffer_from_image (void) { GLboolean r = GL_FALSE; @@ -20495,7 +21077,7 @@ GLenum eglewInit (EGLDisplay display) if (!initialize || !queryString) return 1; - /* query EGK version */ + /* query EGL version */ if (initialize(display, &major, &minor) != EGL_TRUE) return 1; @@ -20567,6 +21149,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_ANDROID_recordable EGLEW_ANDROID_recordable = _glewSearchExtension("EGL_ANDROID_recordable", extStart, extEnd); #endif /* EGL_ANDROID_recordable */ +#ifdef EGL_ANDROID_telemetry_hint + EGLEW_ANDROID_telemetry_hint = _glewSearchExtension("EGL_ANDROID_telemetry_hint", extStart, extEnd); +#endif /* EGL_ANDROID_telemetry_hint */ #ifdef EGL_ANGLE_d3d_share_handle_client_buffer EGLEW_ANGLE_d3d_share_handle_client_buffer = _glewSearchExtension("EGL_ANGLE_d3d_share_handle_client_buffer", extStart, extEnd); #endif /* EGL_ANGLE_d3d_share_handle_client_buffer */ @@ -20580,6 +21165,10 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = _glewSearchExtension("EGL_ANGLE_surface_d3d_texture_2d_share_handle", extStart, extEnd); #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */ +#ifdef EGL_ANGLE_sync_control_rate + EGLEW_ANGLE_sync_control_rate = _glewSearchExtension("EGL_ANGLE_sync_control_rate", extStart, extEnd); + if (glewExperimental || EGLEW_ANGLE_sync_control_rate) EGLEW_ANGLE_sync_control_rate = !_glewInit_EGL_ANGLE_sync_control_rate(); +#endif /* EGL_ANGLE_sync_control_rate */ #ifdef EGL_ANGLE_window_fixed_size EGLEW_ANGLE_window_fixed_size = _glewSearchExtension("EGL_ANGLE_window_fixed_size", extStart, extEnd); #endif /* EGL_ANGLE_window_fixed_size */ @@ -20609,6 +21198,9 @@ GLenum eglewInit (EGLDisplay display) EGLEW_EXT_compositor = _glewSearchExtension("EGL_EXT_compositor", extStart, extEnd); if (glewExperimental || EGLEW_EXT_compositor) EGLEW_EXT_compositor = !_glewInit_EGL_EXT_compositor(); #endif /* EGL_EXT_compositor */ +#ifdef EGL_EXT_config_select_group + EGLEW_EXT_config_select_group = _glewSearchExtension("EGL_EXT_config_select_group", extStart, extEnd); +#endif /* EGL_EXT_config_select_group */ #ifdef EGL_EXT_create_context_robustness EGLEW_EXT_create_context_robustness = _glewSearchExtension("EGL_EXT_create_context_robustness", extStart, extEnd); #endif /* EGL_EXT_create_context_robustness */ @@ -20618,6 +21210,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_device_drm EGLEW_EXT_device_drm = _glewSearchExtension("EGL_EXT_device_drm", extStart, extEnd); #endif /* EGL_EXT_device_drm */ +#ifdef EGL_EXT_device_drm_render_node + EGLEW_EXT_device_drm_render_node = _glewSearchExtension("EGL_EXT_device_drm_render_node", extStart, extEnd); +#endif /* EGL_EXT_device_drm_render_node */ #ifdef EGL_EXT_device_enumeration EGLEW_EXT_device_enumeration = _glewSearchExtension("EGL_EXT_device_enumeration", extStart, extEnd); if (glewExperimental || EGLEW_EXT_device_enumeration) EGLEW_EXT_device_enumeration = !_glewInit_EGL_EXT_device_enumeration(); @@ -20625,10 +21220,27 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_device_openwf EGLEW_EXT_device_openwf = _glewSearchExtension("EGL_EXT_device_openwf", extStart, extEnd); #endif /* EGL_EXT_device_openwf */ +#ifdef EGL_EXT_device_persistent_id + EGLEW_EXT_device_persistent_id = _glewSearchExtension("EGL_EXT_device_persistent_id", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_device_persistent_id) EGLEW_EXT_device_persistent_id = !_glewInit_EGL_EXT_device_persistent_id(); +#endif /* EGL_EXT_device_persistent_id */ #ifdef EGL_EXT_device_query EGLEW_EXT_device_query = _glewSearchExtension("EGL_EXT_device_query", extStart, extEnd); if (glewExperimental || EGLEW_EXT_device_query) EGLEW_EXT_device_query = !_glewInit_EGL_EXT_device_query(); #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_device_query_name + EGLEW_EXT_device_query_name = _glewSearchExtension("EGL_EXT_device_query_name", extStart, extEnd); +#endif /* EGL_EXT_device_query_name */ +#ifdef EGL_EXT_display_alloc + EGLEW_EXT_display_alloc = _glewSearchExtension("EGL_EXT_display_alloc", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_display_alloc) EGLEW_EXT_display_alloc = !_glewInit_EGL_EXT_display_alloc(); +#endif /* EGL_EXT_display_alloc */ +#ifdef EGL_EXT_explicit_device + EGLEW_EXT_explicit_device = _glewSearchExtension("EGL_EXT_explicit_device", extStart, extEnd); +#endif /* EGL_EXT_explicit_device */ +#ifdef EGL_EXT_gl_colorspace_bt2020_hlg + EGLEW_EXT_gl_colorspace_bt2020_hlg = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_hlg", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */ #ifdef EGL_EXT_gl_colorspace_bt2020_linear EGLEW_EXT_gl_colorspace_bt2020_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_linear", extStart, extEnd); #endif /* EGL_EXT_gl_colorspace_bt2020_linear */ @@ -20692,12 +21304,21 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_platform_x11 EGLEW_EXT_platform_x11 = _glewSearchExtension("EGL_EXT_platform_x11", extStart, extEnd); #endif /* EGL_EXT_platform_x11 */ +#ifdef EGL_EXT_platform_xcb + EGLEW_EXT_platform_xcb = _glewSearchExtension("EGL_EXT_platform_xcb", extStart, extEnd); +#endif /* EGL_EXT_platform_xcb */ +#ifdef EGL_EXT_present_opaque + EGLEW_EXT_present_opaque = _glewSearchExtension("EGL_EXT_present_opaque", extStart, extEnd); +#endif /* EGL_EXT_present_opaque */ #ifdef EGL_EXT_protected_content EGLEW_EXT_protected_content = _glewSearchExtension("EGL_EXT_protected_content", extStart, extEnd); #endif /* EGL_EXT_protected_content */ #ifdef EGL_EXT_protected_surface EGLEW_EXT_protected_surface = _glewSearchExtension("EGL_EXT_protected_surface", extStart, extEnd); #endif /* EGL_EXT_protected_surface */ +#ifdef EGL_EXT_query_reset_notification_strategy + EGLEW_EXT_query_reset_notification_strategy = _glewSearchExtension("EGL_EXT_query_reset_notification_strategy", extStart, extEnd); +#endif /* EGL_EXT_query_reset_notification_strategy */ #ifdef EGL_EXT_stream_consumer_egloutput EGLEW_EXT_stream_consumer_egloutput = _glewSearchExtension("EGL_EXT_stream_consumer_egloutput", extStart, extEnd); if (glewExperimental || EGLEW_EXT_stream_consumer_egloutput) EGLEW_EXT_stream_consumer_egloutput = !_glewInit_EGL_EXT_stream_consumer_egloutput(); @@ -20708,6 +21329,10 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_surface_SMPTE2086_metadata EGLEW_EXT_surface_SMPTE2086_metadata = _glewSearchExtension("EGL_EXT_surface_SMPTE2086_metadata", extStart, extEnd); #endif /* EGL_EXT_surface_SMPTE2086_metadata */ +#ifdef EGL_EXT_surface_compression + EGLEW_EXT_surface_compression = _glewSearchExtension("EGL_EXT_surface_compression", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_surface_compression) EGLEW_EXT_surface_compression = !_glewInit_EGL_EXT_surface_compression(); +#endif /* EGL_EXT_surface_compression */ #ifdef EGL_EXT_swap_buffers_with_damage EGLEW_EXT_swap_buffers_with_damage = _glewSearchExtension("EGL_EXT_swap_buffers_with_damage", extStart, extEnd); if (glewExperimental || EGLEW_EXT_swap_buffers_with_damage) EGLEW_EXT_swap_buffers_with_damage = !_glewInit_EGL_EXT_swap_buffers_with_damage(); @@ -20938,6 +21563,13 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_NV_robustness_video_memory_purge EGLEW_NV_robustness_video_memory_purge = _glewSearchExtension("EGL_NV_robustness_video_memory_purge", extStart, extEnd); #endif /* EGL_NV_robustness_video_memory_purge */ +#ifdef EGL_NV_stream_consumer_eglimage + EGLEW_NV_stream_consumer_eglimage = _glewSearchExtension("EGL_NV_stream_consumer_eglimage", extStart, extEnd); + if (glewExperimental || EGLEW_NV_stream_consumer_eglimage) EGLEW_NV_stream_consumer_eglimage = !_glewInit_EGL_NV_stream_consumer_eglimage(); +#endif /* EGL_NV_stream_consumer_eglimage */ +#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib + EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib = _glewSearchExtension("EGL_NV_stream_consumer_eglimage_use_scanout_attrib", extStart, extEnd); +#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */ #ifdef EGL_NV_stream_consumer_gltexture_yuv EGLEW_NV_stream_consumer_gltexture_yuv = _glewSearchExtension("EGL_NV_stream_consumer_gltexture_yuv", extStart, extEnd); if (glewExperimental || EGLEW_NV_stream_consumer_gltexture_yuv) EGLEW_NV_stream_consumer_gltexture_yuv = !_glewInit_EGL_NV_stream_consumer_gltexture_yuv(); @@ -21011,6 +21643,12 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_NV_triple_buffer EGLEW_NV_triple_buffer = _glewSearchExtension("EGL_NV_triple_buffer", extStart, extEnd); #endif /* EGL_NV_triple_buffer */ +#ifdef EGL_QNX_image_native_buffer + EGLEW_QNX_image_native_buffer = _glewSearchExtension("EGL_QNX_image_native_buffer", extStart, extEnd); +#endif /* EGL_QNX_image_native_buffer */ +#ifdef EGL_QNX_platform_screen + EGLEW_QNX_platform_screen = _glewSearchExtension("EGL_QNX_platform_screen", extStart, extEnd); +#endif /* EGL_QNX_platform_screen */ #ifdef EGL_TIZEN_image_native_buffer EGLEW_TIZEN_image_native_buffer = _glewSearchExtension("EGL_TIZEN_image_native_buffer", extStart, extEnd); #endif /* EGL_TIZEN_image_native_buffer */ @@ -21239,7 +21877,7 @@ GLboolean __WGLEW_NV_video_output = GL_FALSE; GLboolean __WGLEW_OML_sync_control = GL_FALSE; #ifdef WGL_3DL_stereo_control -static GLboolean _glewInit_WGL_3DL_stereo_control () +static GLboolean _glewInit_WGL_3DL_stereo_control (void) { GLboolean r = GL_FALSE; @@ -21252,7 +21890,7 @@ static GLboolean _glewInit_WGL_3DL_stereo_control () #ifdef WGL_AMD_gpu_association -static GLboolean _glewInit_WGL_AMD_gpu_association () +static GLboolean _glewInit_WGL_AMD_gpu_association (void) { GLboolean r = GL_FALSE; @@ -21273,7 +21911,7 @@ static GLboolean _glewInit_WGL_AMD_gpu_association () #ifdef WGL_ARB_buffer_region -static GLboolean _glewInit_WGL_ARB_buffer_region () +static GLboolean _glewInit_WGL_ARB_buffer_region (void) { GLboolean r = GL_FALSE; @@ -21289,7 +21927,7 @@ static GLboolean _glewInit_WGL_ARB_buffer_region () #ifdef WGL_ARB_create_context -static GLboolean _glewInit_WGL_ARB_create_context () +static GLboolean _glewInit_WGL_ARB_create_context (void) { GLboolean r = GL_FALSE; @@ -21302,7 +21940,7 @@ static GLboolean _glewInit_WGL_ARB_create_context () #ifdef WGL_ARB_extensions_string -static GLboolean _glewInit_WGL_ARB_extensions_string () +static GLboolean _glewInit_WGL_ARB_extensions_string (void) { GLboolean r = GL_FALSE; @@ -21315,7 +21953,7 @@ static GLboolean _glewInit_WGL_ARB_extensions_string () #ifdef WGL_ARB_make_current_read -static GLboolean _glewInit_WGL_ARB_make_current_read () +static GLboolean _glewInit_WGL_ARB_make_current_read (void) { GLboolean r = GL_FALSE; @@ -21329,7 +21967,7 @@ static GLboolean _glewInit_WGL_ARB_make_current_read () #ifdef WGL_ARB_pbuffer -static GLboolean _glewInit_WGL_ARB_pbuffer () +static GLboolean _glewInit_WGL_ARB_pbuffer (void) { GLboolean r = GL_FALSE; @@ -21346,7 +21984,7 @@ static GLboolean _glewInit_WGL_ARB_pbuffer () #ifdef WGL_ARB_pixel_format -static GLboolean _glewInit_WGL_ARB_pixel_format () +static GLboolean _glewInit_WGL_ARB_pixel_format (void) { GLboolean r = GL_FALSE; @@ -21361,7 +21999,7 @@ static GLboolean _glewInit_WGL_ARB_pixel_format () #ifdef WGL_ARB_render_texture -static GLboolean _glewInit_WGL_ARB_render_texture () +static GLboolean _glewInit_WGL_ARB_render_texture (void) { GLboolean r = GL_FALSE; @@ -21376,7 +22014,7 @@ static GLboolean _glewInit_WGL_ARB_render_texture () #ifdef WGL_EXT_display_color_table -static GLboolean _glewInit_WGL_EXT_display_color_table () +static GLboolean _glewInit_WGL_EXT_display_color_table (void) { GLboolean r = GL_FALSE; @@ -21392,7 +22030,7 @@ static GLboolean _glewInit_WGL_EXT_display_color_table () #ifdef WGL_EXT_extensions_string -static GLboolean _glewInit_WGL_EXT_extensions_string () +static GLboolean _glewInit_WGL_EXT_extensions_string (void) { GLboolean r = GL_FALSE; @@ -21405,7 +22043,7 @@ static GLboolean _glewInit_WGL_EXT_extensions_string () #ifdef WGL_EXT_make_current_read -static GLboolean _glewInit_WGL_EXT_make_current_read () +static GLboolean _glewInit_WGL_EXT_make_current_read (void) { GLboolean r = GL_FALSE; @@ -21419,7 +22057,7 @@ static GLboolean _glewInit_WGL_EXT_make_current_read () #ifdef WGL_EXT_pbuffer -static GLboolean _glewInit_WGL_EXT_pbuffer () +static GLboolean _glewInit_WGL_EXT_pbuffer (void) { GLboolean r = GL_FALSE; @@ -21436,7 +22074,7 @@ static GLboolean _glewInit_WGL_EXT_pbuffer () #ifdef WGL_EXT_pixel_format -static GLboolean _glewInit_WGL_EXT_pixel_format () +static GLboolean _glewInit_WGL_EXT_pixel_format (void) { GLboolean r = GL_FALSE; @@ -21451,7 +22089,7 @@ static GLboolean _glewInit_WGL_EXT_pixel_format () #ifdef WGL_EXT_swap_control -static GLboolean _glewInit_WGL_EXT_swap_control () +static GLboolean _glewInit_WGL_EXT_swap_control (void) { GLboolean r = GL_FALSE; @@ -21465,7 +22103,7 @@ static GLboolean _glewInit_WGL_EXT_swap_control () #ifdef WGL_I3D_digital_video_control -static GLboolean _glewInit_WGL_I3D_digital_video_control () +static GLboolean _glewInit_WGL_I3D_digital_video_control (void) { GLboolean r = GL_FALSE; @@ -21479,7 +22117,7 @@ static GLboolean _glewInit_WGL_I3D_digital_video_control () #ifdef WGL_I3D_gamma -static GLboolean _glewInit_WGL_I3D_gamma () +static GLboolean _glewInit_WGL_I3D_gamma (void) { GLboolean r = GL_FALSE; @@ -21495,7 +22133,7 @@ static GLboolean _glewInit_WGL_I3D_gamma () #ifdef WGL_I3D_genlock -static GLboolean _glewInit_WGL_I3D_genlock () +static GLboolean _glewInit_WGL_I3D_genlock (void) { GLboolean r = GL_FALSE; @@ -21519,7 +22157,7 @@ static GLboolean _glewInit_WGL_I3D_genlock () #ifdef WGL_I3D_image_buffer -static GLboolean _glewInit_WGL_I3D_image_buffer () +static GLboolean _glewInit_WGL_I3D_image_buffer (void) { GLboolean r = GL_FALSE; @@ -21535,7 +22173,7 @@ static GLboolean _glewInit_WGL_I3D_image_buffer () #ifdef WGL_I3D_swap_frame_lock -static GLboolean _glewInit_WGL_I3D_swap_frame_lock () +static GLboolean _glewInit_WGL_I3D_swap_frame_lock (void) { GLboolean r = GL_FALSE; @@ -21551,7 +22189,7 @@ static GLboolean _glewInit_WGL_I3D_swap_frame_lock () #ifdef WGL_I3D_swap_frame_usage -static GLboolean _glewInit_WGL_I3D_swap_frame_usage () +static GLboolean _glewInit_WGL_I3D_swap_frame_usage (void) { GLboolean r = GL_FALSE; @@ -21567,7 +22205,7 @@ static GLboolean _glewInit_WGL_I3D_swap_frame_usage () #ifdef WGL_NV_DX_interop -static GLboolean _glewInit_WGL_NV_DX_interop () +static GLboolean _glewInit_WGL_NV_DX_interop (void) { GLboolean r = GL_FALSE; @@ -21587,7 +22225,7 @@ static GLboolean _glewInit_WGL_NV_DX_interop () #ifdef WGL_NV_copy_image -static GLboolean _glewInit_WGL_NV_copy_image () +static GLboolean _glewInit_WGL_NV_copy_image (void) { GLboolean r = GL_FALSE; @@ -21600,7 +22238,7 @@ static GLboolean _glewInit_WGL_NV_copy_image () #ifdef WGL_NV_delay_before_swap -static GLboolean _glewInit_WGL_NV_delay_before_swap () +static GLboolean _glewInit_WGL_NV_delay_before_swap (void) { GLboolean r = GL_FALSE; @@ -21613,7 +22251,7 @@ static GLboolean _glewInit_WGL_NV_delay_before_swap () #ifdef WGL_NV_gpu_affinity -static GLboolean _glewInit_WGL_NV_gpu_affinity () +static GLboolean _glewInit_WGL_NV_gpu_affinity (void) { GLboolean r = GL_FALSE; @@ -21630,7 +22268,7 @@ static GLboolean _glewInit_WGL_NV_gpu_affinity () #ifdef WGL_NV_present_video -static GLboolean _glewInit_WGL_NV_present_video () +static GLboolean _glewInit_WGL_NV_present_video (void) { GLboolean r = GL_FALSE; @@ -21645,7 +22283,7 @@ static GLboolean _glewInit_WGL_NV_present_video () #ifdef WGL_NV_swap_group -static GLboolean _glewInit_WGL_NV_swap_group () +static GLboolean _glewInit_WGL_NV_swap_group (void) { GLboolean r = GL_FALSE; @@ -21663,7 +22301,7 @@ static GLboolean _glewInit_WGL_NV_swap_group () #ifdef WGL_NV_vertex_array_range -static GLboolean _glewInit_WGL_NV_vertex_array_range () +static GLboolean _glewInit_WGL_NV_vertex_array_range (void) { GLboolean r = GL_FALSE; @@ -21677,7 +22315,7 @@ static GLboolean _glewInit_WGL_NV_vertex_array_range () #ifdef WGL_NV_video_capture -static GLboolean _glewInit_WGL_NV_video_capture () +static GLboolean _glewInit_WGL_NV_video_capture (void) { GLboolean r = GL_FALSE; @@ -21694,7 +22332,7 @@ static GLboolean _glewInit_WGL_NV_video_capture () #ifdef WGL_NV_video_output -static GLboolean _glewInit_WGL_NV_video_output () +static GLboolean _glewInit_WGL_NV_video_output (void) { GLboolean r = GL_FALSE; @@ -21712,7 +22350,7 @@ static GLboolean _glewInit_WGL_NV_video_output () #ifdef WGL_OML_sync_control -static GLboolean _glewInit_WGL_OML_sync_control () +static GLboolean _glewInit_WGL_OML_sync_control (void) { GLboolean r = GL_FALSE; @@ -21750,7 +22388,7 @@ GLboolean GLEWAPIENTRY wglewGetExtension (const char* name) return _glewSearchExtension(name, start, end); } -GLenum GLEWAPIENTRY wglewInit () +GLenum GLEWAPIENTRY wglewInit (void) { GLboolean crippled; const GLubyte* extStart; @@ -22156,6 +22794,7 @@ GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE; GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE; GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE; GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLXEW_EXT_get_drawable_type = GL_FALSE; GLboolean __GLXEW_EXT_import_context = GL_FALSE; GLboolean __GLXEW_EXT_libglvnd = GL_FALSE; GLboolean __GLXEW_EXT_no_config_context = GL_FALSE; @@ -22207,7 +22846,7 @@ GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE; GLboolean __GLXEW_SUN_video_resize = GL_FALSE; #ifdef GLX_VERSION_1_2 -static GLboolean _glewInit_GLX_VERSION_1_2 () +static GLboolean _glewInit_GLX_VERSION_1_2 (void) { GLboolean r = GL_FALSE; @@ -22220,7 +22859,7 @@ static GLboolean _glewInit_GLX_VERSION_1_2 () #ifdef GLX_VERSION_1_3 -static GLboolean _glewInit_GLX_VERSION_1_3 () +static GLboolean _glewInit_GLX_VERSION_1_3 (void) { GLboolean r = GL_FALSE; @@ -22249,7 +22888,7 @@ static GLboolean _glewInit_GLX_VERSION_1_3 () #ifdef GLX_AMD_gpu_association -static GLboolean _glewInit_GLX_AMD_gpu_association () +static GLboolean _glewInit_GLX_AMD_gpu_association (void) { GLboolean r = GL_FALSE; @@ -22270,7 +22909,7 @@ static GLboolean _glewInit_GLX_AMD_gpu_association () #ifdef GLX_ARB_create_context -static GLboolean _glewInit_GLX_ARB_create_context () +static GLboolean _glewInit_GLX_ARB_create_context (void) { GLboolean r = GL_FALSE; @@ -22283,7 +22922,7 @@ static GLboolean _glewInit_GLX_ARB_create_context () #ifdef GLX_ATI_render_texture -static GLboolean _glewInit_GLX_ATI_render_texture () +static GLboolean _glewInit_GLX_ATI_render_texture (void) { GLboolean r = GL_FALSE; @@ -22298,7 +22937,7 @@ static GLboolean _glewInit_GLX_ATI_render_texture () #ifdef GLX_EXT_import_context -static GLboolean _glewInit_GLX_EXT_import_context () +static GLboolean _glewInit_GLX_EXT_import_context (void) { GLboolean r = GL_FALSE; @@ -22315,7 +22954,7 @@ static GLboolean _glewInit_GLX_EXT_import_context () #ifdef GLX_EXT_swap_control -static GLboolean _glewInit_GLX_EXT_swap_control () +static GLboolean _glewInit_GLX_EXT_swap_control (void) { GLboolean r = GL_FALSE; @@ -22328,7 +22967,7 @@ static GLboolean _glewInit_GLX_EXT_swap_control () #ifdef GLX_EXT_texture_from_pixmap -static GLboolean _glewInit_GLX_EXT_texture_from_pixmap () +static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (void) { GLboolean r = GL_FALSE; @@ -22342,7 +22981,7 @@ static GLboolean _glewInit_GLX_EXT_texture_from_pixmap () #ifdef GLX_MESA_agp_offset -static GLboolean _glewInit_GLX_MESA_agp_offset () +static GLboolean _glewInit_GLX_MESA_agp_offset (void) { GLboolean r = GL_FALSE; @@ -22355,7 +22994,7 @@ static GLboolean _glewInit_GLX_MESA_agp_offset () #ifdef GLX_MESA_copy_sub_buffer -static GLboolean _glewInit_GLX_MESA_copy_sub_buffer () +static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (void) { GLboolean r = GL_FALSE; @@ -22368,7 +23007,7 @@ static GLboolean _glewInit_GLX_MESA_copy_sub_buffer () #ifdef GLX_MESA_pixmap_colormap -static GLboolean _glewInit_GLX_MESA_pixmap_colormap () +static GLboolean _glewInit_GLX_MESA_pixmap_colormap (void) { GLboolean r = GL_FALSE; @@ -22381,7 +23020,7 @@ static GLboolean _glewInit_GLX_MESA_pixmap_colormap () #ifdef GLX_MESA_query_renderer -static GLboolean _glewInit_GLX_MESA_query_renderer () +static GLboolean _glewInit_GLX_MESA_query_renderer (void) { GLboolean r = GL_FALSE; @@ -22397,7 +23036,7 @@ static GLboolean _glewInit_GLX_MESA_query_renderer () #ifdef GLX_MESA_release_buffers -static GLboolean _glewInit_GLX_MESA_release_buffers () +static GLboolean _glewInit_GLX_MESA_release_buffers (void) { GLboolean r = GL_FALSE; @@ -22410,7 +23049,7 @@ static GLboolean _glewInit_GLX_MESA_release_buffers () #ifdef GLX_MESA_set_3dfx_mode -static GLboolean _glewInit_GLX_MESA_set_3dfx_mode () +static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (void) { GLboolean r = GL_FALSE; @@ -22423,7 +23062,7 @@ static GLboolean _glewInit_GLX_MESA_set_3dfx_mode () #ifdef GLX_MESA_swap_control -static GLboolean _glewInit_GLX_MESA_swap_control () +static GLboolean _glewInit_GLX_MESA_swap_control (void) { GLboolean r = GL_FALSE; @@ -22437,7 +23076,7 @@ static GLboolean _glewInit_GLX_MESA_swap_control () #ifdef GLX_NV_copy_buffer -static GLboolean _glewInit_GLX_NV_copy_buffer () +static GLboolean _glewInit_GLX_NV_copy_buffer (void) { GLboolean r = GL_FALSE; @@ -22451,7 +23090,7 @@ static GLboolean _glewInit_GLX_NV_copy_buffer () #ifdef GLX_NV_copy_image -static GLboolean _glewInit_GLX_NV_copy_image () +static GLboolean _glewInit_GLX_NV_copy_image (void) { GLboolean r = GL_FALSE; @@ -22464,7 +23103,7 @@ static GLboolean _glewInit_GLX_NV_copy_image () #ifdef GLX_NV_delay_before_swap -static GLboolean _glewInit_GLX_NV_delay_before_swap () +static GLboolean _glewInit_GLX_NV_delay_before_swap (void) { GLboolean r = GL_FALSE; @@ -22477,7 +23116,7 @@ static GLboolean _glewInit_GLX_NV_delay_before_swap () #ifdef GLX_NV_present_video -static GLboolean _glewInit_GLX_NV_present_video () +static GLboolean _glewInit_GLX_NV_present_video (void) { GLboolean r = GL_FALSE; @@ -22491,7 +23130,7 @@ static GLboolean _glewInit_GLX_NV_present_video () #ifdef GLX_NV_swap_group -static GLboolean _glewInit_GLX_NV_swap_group () +static GLboolean _glewInit_GLX_NV_swap_group (void) { GLboolean r = GL_FALSE; @@ -22509,7 +23148,7 @@ static GLboolean _glewInit_GLX_NV_swap_group () #ifdef GLX_NV_vertex_array_range -static GLboolean _glewInit_GLX_NV_vertex_array_range () +static GLboolean _glewInit_GLX_NV_vertex_array_range (void) { GLboolean r = GL_FALSE; @@ -22523,7 +23162,7 @@ static GLboolean _glewInit_GLX_NV_vertex_array_range () #ifdef GLX_NV_video_capture -static GLboolean _glewInit_GLX_NV_video_capture () +static GLboolean _glewInit_GLX_NV_video_capture (void) { GLboolean r = GL_FALSE; @@ -22540,7 +23179,7 @@ static GLboolean _glewInit_GLX_NV_video_capture () #ifdef GLX_NV_video_out -static GLboolean _glewInit_GLX_NV_video_out () +static GLboolean _glewInit_GLX_NV_video_out (void) { GLboolean r = GL_FALSE; @@ -22558,7 +23197,7 @@ static GLboolean _glewInit_GLX_NV_video_out () #ifdef GLX_OML_sync_control -static GLboolean _glewInit_GLX_OML_sync_control () +static GLboolean _glewInit_GLX_OML_sync_control (void) { GLboolean r = GL_FALSE; @@ -22575,7 +23214,7 @@ static GLboolean _glewInit_GLX_OML_sync_control () #ifdef GLX_SGIX_fbconfig -static GLboolean _glewInit_GLX_SGIX_fbconfig () +static GLboolean _glewInit_GLX_SGIX_fbconfig (void) { GLboolean r = GL_FALSE; @@ -22593,7 +23232,7 @@ static GLboolean _glewInit_GLX_SGIX_fbconfig () #ifdef GLX_SGIX_hyperpipe -static GLboolean _glewInit_GLX_SGIX_hyperpipe () +static GLboolean _glewInit_GLX_SGIX_hyperpipe (void) { GLboolean r = GL_FALSE; @@ -22613,7 +23252,7 @@ static GLboolean _glewInit_GLX_SGIX_hyperpipe () #ifdef GLX_SGIX_pbuffer -static GLboolean _glewInit_GLX_SGIX_pbuffer () +static GLboolean _glewInit_GLX_SGIX_pbuffer (void) { GLboolean r = GL_FALSE; @@ -22630,7 +23269,7 @@ static GLboolean _glewInit_GLX_SGIX_pbuffer () #ifdef GLX_SGIX_swap_barrier -static GLboolean _glewInit_GLX_SGIX_swap_barrier () +static GLboolean _glewInit_GLX_SGIX_swap_barrier (void) { GLboolean r = GL_FALSE; @@ -22644,7 +23283,7 @@ static GLboolean _glewInit_GLX_SGIX_swap_barrier () #ifdef GLX_SGIX_swap_group -static GLboolean _glewInit_GLX_SGIX_swap_group () +static GLboolean _glewInit_GLX_SGIX_swap_group (void) { GLboolean r = GL_FALSE; @@ -22657,7 +23296,7 @@ static GLboolean _glewInit_GLX_SGIX_swap_group () #ifdef GLX_SGIX_video_resize -static GLboolean _glewInit_GLX_SGIX_video_resize () +static GLboolean _glewInit_GLX_SGIX_video_resize (void) { GLboolean r = GL_FALSE; @@ -22674,7 +23313,7 @@ static GLboolean _glewInit_GLX_SGIX_video_resize () #ifdef GLX_SGI_cushion -static GLboolean _glewInit_GLX_SGI_cushion () +static GLboolean _glewInit_GLX_SGI_cushion (void) { GLboolean r = GL_FALSE; @@ -22687,7 +23326,7 @@ static GLboolean _glewInit_GLX_SGI_cushion () #ifdef GLX_SGI_make_current_read -static GLboolean _glewInit_GLX_SGI_make_current_read () +static GLboolean _glewInit_GLX_SGI_make_current_read (void) { GLboolean r = GL_FALSE; @@ -22701,7 +23340,7 @@ static GLboolean _glewInit_GLX_SGI_make_current_read () #ifdef GLX_SGI_swap_control -static GLboolean _glewInit_GLX_SGI_swap_control () +static GLboolean _glewInit_GLX_SGI_swap_control (void) { GLboolean r = GL_FALSE; @@ -22714,7 +23353,7 @@ static GLboolean _glewInit_GLX_SGI_swap_control () #ifdef GLX_SGI_video_sync -static GLboolean _glewInit_GLX_SGI_video_sync () +static GLboolean _glewInit_GLX_SGI_video_sync (void) { GLboolean r = GL_FALSE; @@ -22728,7 +23367,7 @@ static GLboolean _glewInit_GLX_SGI_video_sync () #ifdef GLX_SUN_get_transparent_index -static GLboolean _glewInit_GLX_SUN_get_transparent_index () +static GLboolean _glewInit_GLX_SUN_get_transparent_index (void) { GLboolean r = GL_FALSE; @@ -22741,7 +23380,7 @@ static GLboolean _glewInit_GLX_SUN_get_transparent_index () #ifdef GLX_SUN_video_resize -static GLboolean _glewInit_GLX_SUN_video_resize () +static GLboolean _glewInit_GLX_SUN_video_resize (void) { GLboolean r = GL_FALSE; @@ -22767,7 +23406,7 @@ GLboolean glxewGetExtension (const char* name) return _glewSearchExtension(name, start, end); } -GLenum glxewInit () +GLenum glxewInit (void) { Display* display; int major, minor; @@ -22882,6 +23521,9 @@ GLenum glxewInit () #ifdef GLX_EXT_framebuffer_sRGB GLXEW_EXT_framebuffer_sRGB = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd); #endif /* GLX_EXT_framebuffer_sRGB */ +#ifdef GLX_EXT_get_drawable_type + GLXEW_EXT_get_drawable_type = _glewSearchExtension("GLX_EXT_get_drawable_type", extStart, extEnd); +#endif /* GLX_EXT_get_drawable_type */ #ifdef GLX_EXT_import_context GLXEW_EXT_import_context = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd); if (glewExperimental || GLXEW_EXT_import_context) GLXEW_EXT_import_context = !_glewInit_GLX_EXT_import_context(); @@ -23076,6 +23718,7 @@ const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error) (const GLubyte*)"Missing GL version", (const GLubyte*)"GL 1.1 and up are not supported", (const GLubyte*)"GLX 1.2 and up are not supported", + (const GLubyte*)"No GLX display", (const GLubyte*)"Unknown error" }; const size_t max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1; @@ -23087,9 +23730,9 @@ const GLubyte * GLEWAPIENTRY glewGetString (GLenum name) static const GLubyte* _glewString[] = { (const GLubyte*)NULL, - (const GLubyte*)"2.2.0", - (const GLubyte*)"2", + (const GLubyte*)"2.3.0", (const GLubyte*)"2", + (const GLubyte*)"3", (const GLubyte*)"0" }; const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; @@ -23133,6 +23776,17 @@ int __stdcall DllMainCRTStartup(void* instance, unsigned reason, void* reserved) return 1; } #endif + +#if defined(_WIN32) && defined(GLEW_BUILD) && defined(__clang__) +/* Windows mingw clang requires a DLL entry point */ +int __stdcall _DllMainCRTStartup(void* instance, unsigned reason, void* reserved) +{ + (void) instance; + (void) reason; + (void) reserved; + return 1; +} +#endif GLboolean GLEWAPIENTRY glewIsSupported (const char* name) { const GLubyte* pos = (const GLubyte*)name; @@ -25090,6 +25744,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_ARM_shader_core_properties + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_core_properties", 22)) + { + ret = GLEW_ARM_shader_core_properties; + continue; + } +#endif #ifdef GL_ARM_shader_framebuffer_fetch if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24)) { @@ -25319,6 +25980,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_EGL_image_storage_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_storage_compression", 29)) + { + ret = GLEW_EXT_EGL_image_storage_compression; + continue; + } +#endif #ifdef GL_EXT_EGL_sync if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_sync", 8)) { @@ -25662,6 +26330,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_fragment_shading_rate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate", 21)) + { + ret = GLEW_EXT_fragment_shading_rate; + continue; + } +#endif +#ifdef GL_EXT_fragment_shading_rate_attachment + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate_attachment", 32)) + { + ret = GLEW_EXT_fragment_shading_rate_attachment; + continue; + } +#endif +#ifdef GL_EXT_fragment_shading_rate_primitive + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate_primitive", 31)) + { + ret = GLEW_EXT_fragment_shading_rate_primitive; + continue; + } +#endif #ifdef GL_EXT_framebuffer_blit if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) { @@ -25669,6 +26358,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_framebuffer_blit_layers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit_layers", 23)) + { + ret = GLEW_EXT_framebuffer_blit_layers; + continue; + } +#endif #ifdef GL_EXT_framebuffer_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) { @@ -25816,6 +26512,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_mesh_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_shader", 11)) + { + ret = GLEW_EXT_mesh_shader; + continue; + } +#endif #ifdef GL_EXT_misc_attribute if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14)) { @@ -26096,6 +26799,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_separate_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_depth_stencil", 22)) + { + ret = GLEW_EXT_separate_depth_stencil; + continue; + } +#endif #ifdef GL_EXT_separate_shader_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) { @@ -26110,6 +26820,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_clock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_clock", 12)) + { + ret = GLEW_EXT_shader_clock; + continue; + } +#endif #ifdef GL_EXT_shader_framebuffer_fetch if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24)) { @@ -26187,6 +26904,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_realtime_clock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_realtime_clock", 21)) + { + ret = GLEW_EXT_shader_realtime_clock; + continue; + } +#endif +#ifdef GL_EXT_shader_samples_identical + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_samples_identical", 24)) + { + ret = GLEW_EXT_shader_samples_identical; + continue; + } +#endif #ifdef GL_EXT_shader_texture_lod if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) { @@ -26194,6 +26925,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_texture_samples + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_samples", 22)) + { + ret = GLEW_EXT_shader_texture_samples; + continue; + } +#endif #ifdef GL_EXT_shadow_funcs if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12)) { @@ -26579,6 +27317,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_storage_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_compression", 27)) + { + ret = GLEW_EXT_texture_storage_compression; + continue; + } +#endif #ifdef GL_EXT_texture_swizzle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) { @@ -26741,6 +27486,23 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_HP_texture_lighting; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"HUAWEI_", 7)) + { +#ifdef GL_HUAWEI_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14)) + { + ret = GLEW_HUAWEI_program_binary; + continue; + } +#endif +#ifdef GL_HUAWEI_shader_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary", 13)) + { + ret = GLEW_HUAWEI_shader_binary; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4)) @@ -26818,6 +27580,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_IMG_pvric_end_to_end_signature + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pvric_end_to_end_signature", 26)) + { + ret = GLEW_IMG_pvric_end_to_end_signature; + continue; + } +#endif #ifdef GL_IMG_read_format if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) { @@ -26859,6 +27628,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_IMG_texture_filter_cubic; continue; } +#endif +#ifdef GL_IMG_tile_region_protection + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tile_region_protection", 22)) + { + ret = GLEW_IMG_tile_region_protection; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5)) @@ -27053,6 +27829,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) { +#ifdef GL_MESA_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4)) + { + ret = GLEW_MESA_bgra; + continue; + } +#endif +#ifdef GL_MESA_framebuffer_flip_x + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_flip_x", 18)) + { + ret = GLEW_MESA_framebuffer_flip_x; + continue; + } +#endif #ifdef GL_MESA_framebuffer_flip_y if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_flip_y", 18)) { @@ -27060,6 +27850,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_MESA_framebuffer_swap_xy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_swap_xy", 19)) + { + ret = GLEW_MESA_framebuffer_swap_xy; + continue; + } +#endif #ifdef GL_MESA_pack_invert if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11)) { @@ -27088,6 +27885,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_MESA_texture_const_bandwidth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_const_bandwidth", 23)) + { + ret = GLEW_MESA_texture_const_bandwidth; + continue; + } +#endif #ifdef GL_MESA_tile_raster_order if (_glewStrSame3(&pos, &len, (const GLubyte*)"tile_raster_order", 17)) { @@ -27633,6 +28437,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_memory_object_sparse + if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_sparse", 20)) + { + ret = GLEW_NV_memory_object_sparse; + continue; + } +#endif #ifdef GL_NV_mesh_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_shader", 11)) { @@ -27773,6 +28584,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_primitive_shading_rate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_shading_rate", 22)) + { + ret = GLEW_NV_primitive_shading_rate; + continue; + } +#endif #ifdef GL_NV_query_resource_tag if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_resource_tag", 18)) { @@ -28116,6 +28934,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_timeline_semaphore + if (_glewStrSame3(&pos, &len, (const GLubyte*)"timeline_semaphore", 18)) + { + ret = GLEW_NV_timeline_semaphore; + continue; + } +#endif #ifdef GL_NV_transform_feedback if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) { @@ -28130,6 +28955,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_uniform_buffer_std430_layout + if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_std430_layout", 28)) + { + ret = GLEW_NV_uniform_buffer_std430_layout; + continue; + } +#endif #ifdef GL_NV_uniform_buffer_unified_memory if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_unified_memory", 29)) { @@ -28796,6 +29628,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_frame_extrapolation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_extrapolation", 19)) + { + ret = GLEW_QCOM_frame_extrapolation; + continue; + } +#endif #ifdef GL_QCOM_framebuffer_foveated if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_foveated", 20)) { @@ -28803,6 +29642,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_motion_estimation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"motion_estimation", 17)) + { + ret = GLEW_QCOM_motion_estimation; + continue; + } +#endif #ifdef GL_QCOM_perfmon_global_mode if (_glewStrSame3(&pos, &len, (const GLubyte*)"perfmon_global_mode", 19)) { @@ -28810,6 +29656,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_render_sRGB_R8_RG8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_sRGB_R8_RG8", 18)) + { + ret = GLEW_QCOM_render_sRGB_R8_RG8; + continue; + } +#endif +#ifdef GL_QCOM_render_shared_exponent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_shared_exponent", 22)) + { + ret = GLEW_QCOM_render_shared_exponent; + continue; + } +#endif #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_noncoherent", 36)) { @@ -28824,6 +29684,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_shading_rate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_rate", 12)) + { + ret = GLEW_QCOM_shading_rate; + continue; + } +#endif #ifdef GL_QCOM_texture_foveated if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated", 16)) { @@ -28831,6 +29698,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_texture_foveated2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated2", 17)) + { + ret = GLEW_QCOM_texture_foveated2; + continue; + } +#endif #ifdef GL_QCOM_texture_foveated_subsampled_layout if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated_subsampled_layout", 34)) { @@ -28838,6 +29712,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_texture_lod_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) + { + ret = GLEW_QCOM_texture_lod_bias; + continue; + } +#endif #ifdef GL_QCOM_tiled_rendering if (_glewStrSame3(&pos, &len, (const GLubyte*)"tiled_rendering", 15)) { @@ -28851,6 +29732,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_QCOM_writeonly_rendering; continue; } +#endif +#ifdef GL_QCOM_ycbcr_degamma + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_degamma", 13)) + { + ret = GLEW_QCOM_ycbcr_degamma; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6)) @@ -30431,6 +31319,13 @@ GLboolean glxewIsSupported (const char* name) continue; } #endif +#ifdef GLX_EXT_get_drawable_type + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_drawable_type", 17)) + { + ret = GLXEW_EXT_get_drawable_type; + continue; + } +#endif #ifdef GLX_EXT_import_context if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14)) { @@ -30939,6 +31834,13 @@ GLboolean eglewIsSupported (const char* name) ret = EGLEW_ANDROID_recordable; continue; } +#endif +#ifdef EGL_ANDROID_telemetry_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"telemetry_hint", 14)) + { + ret = EGLEW_ANDROID_telemetry_hint; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6)) @@ -30971,6 +31873,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_ANGLE_sync_control_rate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control_rate", 17)) + { + ret = EGLEW_ANGLE_sync_control_rate; + continue; + } +#endif #ifdef EGL_ANGLE_window_fixed_size if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_fixed_size", 17)) { @@ -31040,6 +31949,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_config_select_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"config_select_group", 19)) + { + ret = EGLEW_EXT_config_select_group; + continue; + } +#endif #ifdef EGL_EXT_create_context_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) { @@ -31061,6 +31977,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_device_drm_render_node + if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_drm_render_node", 22)) + { + ret = EGLEW_EXT_device_drm_render_node; + continue; + } +#endif #ifdef EGL_EXT_device_enumeration if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_enumeration", 18)) { @@ -31075,6 +31998,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_device_persistent_id + if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_persistent_id", 20)) + { + ret = EGLEW_EXT_device_persistent_id; + continue; + } +#endif #ifdef EGL_EXT_device_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_query", 12)) { @@ -31082,6 +32012,34 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_device_query_name + if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_query_name", 17)) + { + ret = EGLEW_EXT_device_query_name; + continue; + } +#endif +#ifdef EGL_EXT_display_alloc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_alloc", 13)) + { + ret = EGLEW_EXT_display_alloc; + continue; + } +#endif +#ifdef EGL_EXT_explicit_device + if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_device", 15)) + { + ret = EGLEW_EXT_explicit_device; + continue; + } +#endif +#ifdef EGL_EXT_gl_colorspace_bt2020_hlg + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_hlg", 24)) + { + ret = EGLEW_EXT_gl_colorspace_bt2020_hlg; + continue; + } +#endif #ifdef EGL_EXT_gl_colorspace_bt2020_linear if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_linear", 27)) { @@ -31222,6 +32180,20 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_platform_xcb + if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_xcb", 12)) + { + ret = EGLEW_EXT_platform_xcb; + continue; + } +#endif +#ifdef EGL_EXT_present_opaque + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_opaque", 14)) + { + ret = EGLEW_EXT_present_opaque; + continue; + } +#endif #ifdef EGL_EXT_protected_content if (_glewStrSame3(&pos, &len, (const GLubyte*)"protected_content", 17)) { @@ -31236,6 +32208,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_query_reset_notification_strategy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_reset_notification_strategy", 33)) + { + ret = EGLEW_EXT_query_reset_notification_strategy; + continue; + } +#endif #ifdef EGL_EXT_stream_consumer_egloutput if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_egloutput", 25)) { @@ -31257,6 +32236,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_surface_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_compression", 19)) + { + ret = EGLEW_EXT_surface_compression; + continue; + } +#endif #ifdef EGL_EXT_swap_buffers_with_damage if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_buffers_with_damage", 24)) { @@ -31751,6 +32737,20 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_NV_stream_consumer_eglimage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_eglimage", 24)) + { + ret = EGLEW_NV_stream_consumer_eglimage; + continue; + } +#endif +#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_eglimage_use_scanout_attrib", 43)) + { + ret = EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib; + continue; + } +#endif #ifdef EGL_NV_stream_consumer_gltexture_yuv if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_gltexture_yuv", 29)) { @@ -31904,6 +32904,23 @@ GLboolean eglewIsSupported (const char* name) ret = EGLEW_NV_triple_buffer; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"QNX_", 4)) + { +#ifdef EGL_QNX_image_native_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_buffer", 19)) + { + ret = EGLEW_QNX_image_native_buffer; + continue; + } +#endif +#ifdef EGL_QNX_platform_screen + if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_screen", 15)) + { + ret = EGLEW_QNX_platform_screen; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"TIZEN_", 6)) diff --git a/src/glewinfo.c b/src/glewinfo.c index bcfa43f..bf828cb 100644 --- a/src/glewinfo.c +++ b/src/glewinfo.c @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2019, Nigel Stewart +** Copyright (C) 2008-2025, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -37,7 +37,12 @@ #if defined(GLEW_EGL) #include #elif defined(GLEW_OSMESA) +#ifndef GLAPI #define GLAPI extern +#endif +#ifndef APIENTRY +#define APIENTRY +#endif #include #elif defined(_WIN32) #include @@ -81,7 +86,7 @@ GLboolean glewCreateContext (struct createParams *params); GLboolean glewParseArgs (int argc, char** argv, struct createParams *); -void glewDestroyContext (); +void glewDestroyContext (void); /* ------------------------------------------------------------------------- */ @@ -2648,6 +2653,7 @@ static void _glewInfo_GL_ARB_sample_locations (void) { GLboolean fi = glewPrintExt("GL_ARB_sample_locations", GLEW_ARB_sample_locations, glewIsSupported("GL_ARB_sample_locations"), glewGetExtension("GL_ARB_sample_locations")); + glewInfoFunc(fi, "glEvaluateDepthValuesARB", glEvaluateDepthValuesARB == NULL); glewInfoFunc(fi, "glFramebufferSampleLocationsfvARB", glFramebufferSampleLocationsfvARB == NULL); glewInfoFunc(fi, "glNamedFramebufferSampleLocationsfvARB", glNamedFramebufferSampleLocationsfvARB == NULL); } @@ -3873,6 +3879,17 @@ static void _glewInfo_GL_ARM_rgba8 (void) #endif /* GL_ARM_rgba8 */ +#ifdef GL_ARM_shader_core_properties + +static void _glewInfo_GL_ARM_shader_core_properties (void) +{ + GLboolean fi = glewPrintExt("GL_ARM_shader_core_properties", GLEW_ARM_shader_core_properties, glewIsSupported("GL_ARM_shader_core_properties"), glewGetExtension("GL_ARM_shader_core_properties")); + + glewInfoFunc(fi, "glMaxActiveShaderCoresARM", glMaxActiveShaderCoresARM == NULL); +} + +#endif /* GL_ARM_shader_core_properties */ + #ifdef GL_ARM_shader_framebuffer_fetch static void _glewInfo_GL_ARM_shader_framebuffer_fetch (void) @@ -4253,6 +4270,15 @@ static void _glewInfo_GL_EXT_EGL_image_storage (void) #endif /* GL_EXT_EGL_image_storage */ +#ifdef GL_EXT_EGL_image_storage_compression + +static void _glewInfo_GL_EXT_EGL_image_storage_compression (void) +{ + glewPrintExt("GL_EXT_EGL_image_storage_compression", GLEW_EXT_EGL_image_storage_compression, glewIsSupported("GL_EXT_EGL_image_storage_compression"), glewGetExtension("GL_EXT_EGL_image_storage_compression")); +} + +#endif /* GL_EXT_EGL_image_storage_compression */ + #ifdef GL_EXT_EGL_sync static void _glewInfo_GL_EXT_EGL_sync (void) @@ -4397,7 +4423,6 @@ static void _glewInfo_GL_EXT_buffer_storage (void) GLboolean fi = glewPrintExt("GL_EXT_buffer_storage", GLEW_EXT_buffer_storage, glewIsSupported("GL_EXT_buffer_storage"), glewGetExtension("GL_EXT_buffer_storage")); glewInfoFunc(fi, "glBufferStorageEXT", glBufferStorageEXT == NULL); - glewInfoFunc(fi, "glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL); } #endif /* GL_EXT_buffer_storage */ @@ -4827,6 +4852,7 @@ static void _glewInfo_GL_EXT_direct_state_access (void) glewInfoFunc(fi, "glTextureImage1DEXT", glTextureImage1DEXT == NULL); glewInfoFunc(fi, "glTextureImage2DEXT", glTextureImage2DEXT == NULL); glewInfoFunc(fi, "glTextureImage3DEXT", glTextureImage3DEXT == NULL); + glewInfoFunc(fi, "glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL); glewInfoFunc(fi, "glTextureParameterIivEXT", glTextureParameterIivEXT == NULL); glewInfoFunc(fi, "glTextureParameterIuivEXT", glTextureParameterIuivEXT == NULL); glewInfoFunc(fi, "glTextureParameterfEXT", glTextureParameterfEXT == NULL); @@ -5052,6 +5078,38 @@ static void _glewInfo_GL_EXT_fragment_lighting (void) #endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_fragment_shading_rate + +static void _glewInfo_GL_EXT_fragment_shading_rate (void) +{ + GLboolean fi = glewPrintExt("GL_EXT_fragment_shading_rate", GLEW_EXT_fragment_shading_rate, glewIsSupported("GL_EXT_fragment_shading_rate"), glewGetExtension("GL_EXT_fragment_shading_rate")); + + glewInfoFunc(fi, "glFramebufferShadingRateEXT", glFramebufferShadingRateEXT == NULL); + glewInfoFunc(fi, "glGetFragmentShadingRatesEXT", glGetFragmentShadingRatesEXT == NULL); + glewInfoFunc(fi, "glShadingRateCombinerOpsEXT", glShadingRateCombinerOpsEXT == NULL); + glewInfoFunc(fi, "glShadingRateEXT", glShadingRateEXT == NULL); +} + +#endif /* GL_EXT_fragment_shading_rate */ + +#ifdef GL_EXT_fragment_shading_rate_attachment + +static void _glewInfo_GL_EXT_fragment_shading_rate_attachment (void) +{ + glewPrintExt("GL_EXT_fragment_shading_rate_attachment", GLEW_EXT_fragment_shading_rate_attachment, glewIsSupported("GL_EXT_fragment_shading_rate_attachment"), glewGetExtension("GL_EXT_fragment_shading_rate_attachment")); +} + +#endif /* GL_EXT_fragment_shading_rate_attachment */ + +#ifdef GL_EXT_fragment_shading_rate_primitive + +static void _glewInfo_GL_EXT_fragment_shading_rate_primitive (void) +{ + glewPrintExt("GL_EXT_fragment_shading_rate_primitive", GLEW_EXT_fragment_shading_rate_primitive, glewIsSupported("GL_EXT_fragment_shading_rate_primitive"), glewGetExtension("GL_EXT_fragment_shading_rate_primitive")); +} + +#endif /* GL_EXT_fragment_shading_rate_primitive */ + #ifdef GL_EXT_framebuffer_blit static void _glewInfo_GL_EXT_framebuffer_blit (void) @@ -5063,6 +5121,18 @@ static void _glewInfo_GL_EXT_framebuffer_blit (void) #endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_blit_layers + +static void _glewInfo_GL_EXT_framebuffer_blit_layers (void) +{ + GLboolean fi = glewPrintExt("GL_EXT_framebuffer_blit_layers", GLEW_EXT_framebuffer_blit_layers, glewIsSupported("GL_EXT_framebuffer_blit_layers"), glewGetExtension("GL_EXT_framebuffer_blit_layers")); + + glewInfoFunc(fi, "glBlitFramebufferLayerEXT", glBlitFramebufferLayerEXT == NULL); + glewInfoFunc(fi, "glBlitFramebufferLayersEXT", glBlitFramebufferLayersEXT == NULL); +} + +#endif /* GL_EXT_framebuffer_blit_layers */ + #ifdef GL_EXT_framebuffer_multisample static void _glewInfo_GL_EXT_framebuffer_multisample (void) @@ -5363,6 +5433,20 @@ static void _glewInfo_GL_EXT_memory_object_win32 (void) #endif /* GL_EXT_memory_object_win32 */ +#ifdef GL_EXT_mesh_shader + +static void _glewInfo_GL_EXT_mesh_shader (void) +{ + GLboolean fi = glewPrintExt("GL_EXT_mesh_shader", GLEW_EXT_mesh_shader, glewIsSupported("GL_EXT_mesh_shader"), glewGetExtension("GL_EXT_mesh_shader")); + + glewInfoFunc(fi, "glDrawMeshTasksEXT", glDrawMeshTasksEXT == NULL); + glewInfoFunc(fi, "glDrawMeshTasksIndirectEXT", glDrawMeshTasksIndirectEXT == NULL); + glewInfoFunc(fi, "glMultiDrawMeshTasksIndirectCountEXT", glMultiDrawMeshTasksIndirectCountEXT == NULL); + glewInfoFunc(fi, "glMultiDrawMeshTasksIndirectEXT", glMultiDrawMeshTasksIndirectEXT == NULL); +} + +#endif /* GL_EXT_mesh_shader */ + #ifdef GL_EXT_misc_attribute static void _glewInfo_GL_EXT_misc_attribute (void) @@ -5700,6 +5784,7 @@ static void _glewInfo_GL_EXT_robustness (void) { GLboolean fi = glewPrintExt("GL_EXT_robustness", GLEW_EXT_robustness, glewIsSupported("GL_EXT_robustness"), glewGetExtension("GL_EXT_robustness")); + glewInfoFunc(fi, "glGetGraphicsResetStatusEXT", glGetGraphicsResetStatusEXT == NULL); glewInfoFunc(fi, "glGetnUniformfvEXT", glGetnUniformfvEXT == NULL); glewInfoFunc(fi, "glGetnUniformivEXT", glGetnUniformivEXT == NULL); glewInfoFunc(fi, "glReadnPixelsEXT", glReadnPixelsEXT == NULL); @@ -5804,6 +5889,15 @@ static void _glewInfo_GL_EXT_semaphore_win32 (void) #endif /* GL_EXT_semaphore_win32 */ +#ifdef GL_EXT_separate_depth_stencil + +static void _glewInfo_GL_EXT_separate_depth_stencil (void) +{ + glewPrintExt("GL_EXT_separate_depth_stencil", GLEW_EXT_separate_depth_stencil, glewIsSupported("GL_EXT_separate_depth_stencil"), glewGetExtension("GL_EXT_separate_depth_stencil")); +} + +#endif /* GL_EXT_separate_depth_stencil */ + #ifdef GL_EXT_separate_shader_objects static void _glewInfo_GL_EXT_separate_shader_objects (void) @@ -5826,6 +5920,15 @@ static void _glewInfo_GL_EXT_separate_specular_color (void) #endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shader_clock + +static void _glewInfo_GL_EXT_shader_clock (void) +{ + glewPrintExt("GL_EXT_shader_clock", GLEW_EXT_shader_clock, glewIsSupported("GL_EXT_shader_clock"), glewGetExtension("GL_EXT_shader_clock")); +} + +#endif /* GL_EXT_shader_clock */ + #ifdef GL_EXT_shader_framebuffer_fetch static void _glewInfo_GL_EXT_shader_framebuffer_fetch (void) @@ -5934,6 +6037,24 @@ static void _glewInfo_GL_EXT_shader_pixel_local_storage2 (void) #endif /* GL_EXT_shader_pixel_local_storage2 */ +#ifdef GL_EXT_shader_realtime_clock + +static void _glewInfo_GL_EXT_shader_realtime_clock (void) +{ + glewPrintExt("GL_EXT_shader_realtime_clock", GLEW_EXT_shader_realtime_clock, glewIsSupported("GL_EXT_shader_realtime_clock"), glewGetExtension("GL_EXT_shader_realtime_clock")); +} + +#endif /* GL_EXT_shader_realtime_clock */ + +#ifdef GL_EXT_shader_samples_identical + +static void _glewInfo_GL_EXT_shader_samples_identical (void) +{ + glewPrintExt("GL_EXT_shader_samples_identical", GLEW_EXT_shader_samples_identical, glewIsSupported("GL_EXT_shader_samples_identical"), glewGetExtension("GL_EXT_shader_samples_identical")); +} + +#endif /* GL_EXT_shader_samples_identical */ + #ifdef GL_EXT_shader_texture_lod static void _glewInfo_GL_EXT_shader_texture_lod (void) @@ -5943,6 +6064,15 @@ static void _glewInfo_GL_EXT_shader_texture_lod (void) #endif /* GL_EXT_shader_texture_lod */ +#ifdef GL_EXT_shader_texture_samples + +static void _glewInfo_GL_EXT_shader_texture_samples (void) +{ + glewPrintExt("GL_EXT_shader_texture_samples", GLEW_EXT_shader_texture_samples, glewIsSupported("GL_EXT_shader_texture_samples"), glewGetExtension("GL_EXT_shader_texture_samples")); +} + +#endif /* GL_EXT_shader_texture_samples */ + #ifdef GL_EXT_shadow_funcs static void _glewInfo_GL_EXT_shadow_funcs (void) @@ -5977,7 +6107,6 @@ static void _glewInfo_GL_EXT_sparse_texture (void) GLboolean fi = glewPrintExt("GL_EXT_sparse_texture", GLEW_EXT_sparse_texture, glewIsSupported("GL_EXT_sparse_texture"), glewGetExtension("GL_EXT_sparse_texture")); glewInfoFunc(fi, "glTexPageCommitmentEXT", glTexPageCommitmentEXT == NULL); - glewInfoFunc(fi, "glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL); } #endif /* GL_EXT_sparse_texture */ @@ -6483,6 +6612,18 @@ static void _glewInfo_GL_EXT_texture_storage (void) #endif /* GL_EXT_texture_storage */ +#ifdef GL_EXT_texture_storage_compression + +static void _glewInfo_GL_EXT_texture_storage_compression (void) +{ + GLboolean fi = glewPrintExt("GL_EXT_texture_storage_compression", GLEW_EXT_texture_storage_compression, glewIsSupported("GL_EXT_texture_storage_compression"), glewGetExtension("GL_EXT_texture_storage_compression")); + + glewInfoFunc(fi, "glTexStorageAttribs2DEXT", glTexStorageAttribs2DEXT == NULL); + glewInfoFunc(fi, "glTexStorageAttribs3DEXT", glTexStorageAttribs3DEXT == NULL); +} + +#endif /* GL_EXT_texture_storage_compression */ + #ifdef GL_EXT_texture_swizzle static void _glewInfo_GL_EXT_texture_swizzle (void) @@ -6784,6 +6925,24 @@ static void _glewInfo_GL_HP_texture_lighting (void) #endif /* GL_HP_texture_lighting */ +#ifdef GL_HUAWEI_program_binary + +static void _glewInfo_GL_HUAWEI_program_binary (void) +{ + glewPrintExt("GL_HUAWEI_program_binary", GLEW_HUAWEI_program_binary, glewIsSupported("GL_HUAWEI_program_binary"), glewGetExtension("GL_HUAWEI_program_binary")); +} + +#endif /* GL_HUAWEI_program_binary */ + +#ifdef GL_HUAWEI_shader_binary + +static void _glewInfo_GL_HUAWEI_shader_binary (void) +{ + glewPrintExt("GL_HUAWEI_shader_binary", GLEW_HUAWEI_shader_binary, glewIsSupported("GL_HUAWEI_shader_binary"), glewGetExtension("GL_HUAWEI_shader_binary")); +} + +#endif /* GL_HUAWEI_shader_binary */ + #ifdef GL_IBM_cull_vertex static void _glewInfo_GL_IBM_cull_vertex (void) @@ -6899,6 +7058,15 @@ static void _glewInfo_GL_IMG_program_binary (void) #endif /* GL_IMG_program_binary */ +#ifdef GL_IMG_pvric_end_to_end_signature + +static void _glewInfo_GL_IMG_pvric_end_to_end_signature (void) +{ + glewPrintExt("GL_IMG_pvric_end_to_end_signature", GLEW_IMG_pvric_end_to_end_signature, glewIsSupported("GL_IMG_pvric_end_to_end_signature"), glewGetExtension("GL_IMG_pvric_end_to_end_signature")); +} + +#endif /* GL_IMG_pvric_end_to_end_signature */ + #ifdef GL_IMG_read_format static void _glewInfo_GL_IMG_read_format (void) @@ -6953,6 +7121,15 @@ static void _glewInfo_GL_IMG_texture_filter_cubic (void) #endif /* GL_IMG_texture_filter_cubic */ +#ifdef GL_IMG_tile_region_protection + +static void _glewInfo_GL_IMG_tile_region_protection (void) +{ + glewPrintExt("GL_IMG_tile_region_protection", GLEW_IMG_tile_region_protection, glewIsSupported("GL_IMG_tile_region_protection"), glewGetExtension("GL_IMG_tile_region_protection")); +} + +#endif /* GL_IMG_tile_region_protection */ + #ifdef GL_INGR_color_clamp static void _glewInfo_GL_INGR_color_clamp (void) @@ -7002,7 +7179,9 @@ static void _glewInfo_GL_INTEL_fragment_shader_ordering (void) static void _glewInfo_GL_INTEL_framebuffer_CMAA (void) { - glewPrintExt("GL_INTEL_framebuffer_CMAA", GLEW_INTEL_framebuffer_CMAA, glewIsSupported("GL_INTEL_framebuffer_CMAA"), glewGetExtension("GL_INTEL_framebuffer_CMAA")); + GLboolean fi = glewPrintExt("GL_INTEL_framebuffer_CMAA", GLEW_INTEL_framebuffer_CMAA, glewIsSupported("GL_INTEL_framebuffer_CMAA"), glewGetExtension("GL_INTEL_framebuffer_CMAA")); + + glewInfoFunc(fi, "glApplyFramebufferAttachmentCMAAINTEL", glApplyFramebufferAttachmentCMAAINTEL == NULL); } #endif /* GL_INTEL_framebuffer_CMAA */ @@ -7227,6 +7406,24 @@ static void _glewInfo_GL_MESAX_texture_stack (void) #endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_bgra + +static void _glewInfo_GL_MESA_bgra (void) +{ + glewPrintExt("GL_MESA_bgra", GLEW_MESA_bgra, glewIsSupported("GL_MESA_bgra"), glewGetExtension("GL_MESA_bgra")); +} + +#endif /* GL_MESA_bgra */ + +#ifdef GL_MESA_framebuffer_flip_x + +static void _glewInfo_GL_MESA_framebuffer_flip_x (void) +{ + glewPrintExt("GL_MESA_framebuffer_flip_x", GLEW_MESA_framebuffer_flip_x, glewIsSupported("GL_MESA_framebuffer_flip_x"), glewGetExtension("GL_MESA_framebuffer_flip_x")); +} + +#endif /* GL_MESA_framebuffer_flip_x */ + #ifdef GL_MESA_framebuffer_flip_y static void _glewInfo_GL_MESA_framebuffer_flip_y (void) @@ -7239,6 +7436,15 @@ static void _glewInfo_GL_MESA_framebuffer_flip_y (void) #endif /* GL_MESA_framebuffer_flip_y */ +#ifdef GL_MESA_framebuffer_swap_xy + +static void _glewInfo_GL_MESA_framebuffer_swap_xy (void) +{ + glewPrintExt("GL_MESA_framebuffer_swap_xy", GLEW_MESA_framebuffer_swap_xy, glewIsSupported("GL_MESA_framebuffer_swap_xy"), glewGetExtension("GL_MESA_framebuffer_swap_xy")); +} + +#endif /* GL_MESA_framebuffer_swap_xy */ + #ifdef GL_MESA_pack_invert static void _glewInfo_GL_MESA_pack_invert (void) @@ -7277,6 +7483,15 @@ static void _glewInfo_GL_MESA_shader_integer_functions (void) #endif /* GL_MESA_shader_integer_functions */ +#ifdef GL_MESA_texture_const_bandwidth + +static void _glewInfo_GL_MESA_texture_const_bandwidth (void) +{ + glewPrintExt("GL_MESA_texture_const_bandwidth", GLEW_MESA_texture_const_bandwidth, glewIsSupported("GL_MESA_texture_const_bandwidth"), glewGetExtension("GL_MESA_texture_const_bandwidth")); +} + +#endif /* GL_MESA_texture_const_bandwidth */ + #ifdef GL_MESA_tile_raster_order static void _glewInfo_GL_MESA_tile_raster_order (void) @@ -7395,6 +7610,7 @@ static void _glewInfo_GL_NVX_progress_fence (void) GLboolean fi = glewPrintExt("GL_NVX_progress_fence", GLEW_NVX_progress_fence, glewIsSupported("GL_NVX_progress_fence"), glewGetExtension("GL_NVX_progress_fence")); glewInfoFunc(fi, "glClientWaitSemaphoreui64NVX", glClientWaitSemaphoreui64NVX == NULL); + glewInfoFunc(fi, "glCreateProgressFenceNVX", glCreateProgressFenceNVX == NULL); glewInfoFunc(fi, "glSignalSemaphoreui64NVX", glSignalSemaphoreui64NVX == NULL); glewInfoFunc(fi, "glWaitSemaphoreui64NVX", glWaitSemaphoreui64NVX == NULL); } @@ -8249,6 +8465,20 @@ static void _glewInfo_GL_NV_memory_attachment (void) #endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_memory_object_sparse + +static void _glewInfo_GL_NV_memory_object_sparse (void) +{ + GLboolean fi = glewPrintExt("GL_NV_memory_object_sparse", GLEW_NV_memory_object_sparse, glewIsSupported("GL_NV_memory_object_sparse"), glewGetExtension("GL_NV_memory_object_sparse")); + + glewInfoFunc(fi, "glBufferPageCommitmentMemNV", glBufferPageCommitmentMemNV == NULL); + glewInfoFunc(fi, "glNamedBufferPageCommitmentMemNV", glNamedBufferPageCommitmentMemNV == NULL); + glewInfoFunc(fi, "glTexPageCommitmentMemNV", glTexPageCommitmentMemNV == NULL); + glewInfoFunc(fi, "glTexturePageCommitmentMemNV", glTexturePageCommitmentMemNV == NULL); +} + +#endif /* GL_NV_memory_object_sparse */ + #ifdef GL_NV_mesh_shader static void _glewInfo_GL_NV_mesh_shader (void) @@ -8536,6 +8766,15 @@ static void _glewInfo_GL_NV_primitive_restart (void) #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_primitive_shading_rate + +static void _glewInfo_GL_NV_primitive_shading_rate (void) +{ + glewPrintExt("GL_NV_primitive_shading_rate", GLEW_NV_primitive_shading_rate, glewIsSupported("GL_NV_primitive_shading_rate"), glewGetExtension("GL_NV_primitive_shading_rate")); +} + +#endif /* GL_NV_primitive_shading_rate */ + #ifdef GL_NV_query_resource_tag static void _glewInfo_GL_NV_query_resource_tag (void) @@ -8822,6 +9061,7 @@ static void _glewInfo_GL_NV_shading_rate_image (void) glewInfoFunc(fi, "glShadingRateImageBarrierNV", glShadingRateImageBarrierNV == NULL); glewInfoFunc(fi, "glShadingRateImagePaletteNV", glShadingRateImagePaletteNV == NULL); glewInfoFunc(fi, "glShadingRateSampleOrderCustomNV", glShadingRateSampleOrderCustomNV == NULL); + glewInfoFunc(fi, "glShadingRateSampleOrderNV", glShadingRateSampleOrderNV == NULL); } #endif /* GL_NV_shading_rate_image */ @@ -9040,6 +9280,19 @@ static void _glewInfo_GL_NV_texture_shader3 (void) #endif /* GL_NV_texture_shader3 */ +#ifdef GL_NV_timeline_semaphore + +static void _glewInfo_GL_NV_timeline_semaphore (void) +{ + GLboolean fi = glewPrintExt("GL_NV_timeline_semaphore", GLEW_NV_timeline_semaphore, glewIsSupported("GL_NV_timeline_semaphore"), glewGetExtension("GL_NV_timeline_semaphore")); + + glewInfoFunc(fi, "glCreateSemaphoresNV", glCreateSemaphoresNV == NULL); + glewInfoFunc(fi, "glGetSemaphoreParameterivNV", glGetSemaphoreParameterivNV == NULL); + glewInfoFunc(fi, "glSemaphoreParameterivNV", glSemaphoreParameterivNV == NULL); +} + +#endif /* GL_NV_timeline_semaphore */ + #ifdef GL_NV_transform_feedback static void _glewInfo_GL_NV_transform_feedback (void) @@ -9078,6 +9331,15 @@ static void _glewInfo_GL_NV_transform_feedback2 (void) #endif /* GL_NV_transform_feedback2 */ +#ifdef GL_NV_uniform_buffer_std430_layout + +static void _glewInfo_GL_NV_uniform_buffer_std430_layout (void) +{ + glewPrintExt("GL_NV_uniform_buffer_std430_layout", GLEW_NV_uniform_buffer_std430_layout, glewIsSupported("GL_NV_uniform_buffer_std430_layout"), glewGetExtension("GL_NV_uniform_buffer_std430_layout")); +} + +#endif /* GL_NV_uniform_buffer_std430_layout */ + #ifdef GL_NV_uniform_buffer_unified_memory static void _glewInfo_GL_NV_uniform_buffer_unified_memory (void) @@ -9666,6 +9928,7 @@ static void _glewInfo_GL_OES_matrix_palette (void) GLboolean fi = glewPrintExt("GL_OES_matrix_palette", GLEW_OES_matrix_palette, glewIsSupported("GL_OES_matrix_palette"), glewGetExtension("GL_OES_matrix_palette")); glewInfoFunc(fi, "glCurrentPaletteMatrixOES", glCurrentPaletteMatrixOES == NULL); + glewInfoFunc(fi, "glLoadPaletteFromModelViewMatrixOES", glLoadPaletteFromModelViewMatrixOES == NULL); glewInfoFunc(fi, "glMatrixIndexPointerOES", glMatrixIndexPointerOES == NULL); glewInfoFunc(fi, "glWeightPointerOES", glWeightPointerOES == NULL); } @@ -10177,6 +10440,17 @@ static void _glewInfo_GL_QCOM_extended_get2 (void) #endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_frame_extrapolation + +static void _glewInfo_GL_QCOM_frame_extrapolation (void) +{ + GLboolean fi = glewPrintExt("GL_QCOM_frame_extrapolation", GLEW_QCOM_frame_extrapolation, glewIsSupported("GL_QCOM_frame_extrapolation"), glewGetExtension("GL_QCOM_frame_extrapolation")); + + glewInfoFunc(fi, "glExtrapolateTex2DQCOM", glExtrapolateTex2DQCOM == NULL); +} + +#endif /* GL_QCOM_frame_extrapolation */ + #ifdef GL_QCOM_framebuffer_foveated static void _glewInfo_GL_QCOM_framebuffer_foveated (void) @@ -10189,6 +10463,18 @@ static void _glewInfo_GL_QCOM_framebuffer_foveated (void) #endif /* GL_QCOM_framebuffer_foveated */ +#ifdef GL_QCOM_motion_estimation + +static void _glewInfo_GL_QCOM_motion_estimation (void) +{ + GLboolean fi = glewPrintExt("GL_QCOM_motion_estimation", GLEW_QCOM_motion_estimation, glewIsSupported("GL_QCOM_motion_estimation"), glewGetExtension("GL_QCOM_motion_estimation")); + + glewInfoFunc(fi, "glTexEstimateMotionQCOM", glTexEstimateMotionQCOM == NULL); + glewInfoFunc(fi, "glTexEstimateMotionRegionsQCOM", glTexEstimateMotionRegionsQCOM == NULL); +} + +#endif /* GL_QCOM_motion_estimation */ + #ifdef GL_QCOM_perfmon_global_mode static void _glewInfo_GL_QCOM_perfmon_global_mode (void) @@ -10198,6 +10484,24 @@ static void _glewInfo_GL_QCOM_perfmon_global_mode (void) #endif /* GL_QCOM_perfmon_global_mode */ +#ifdef GL_QCOM_render_sRGB_R8_RG8 + +static void _glewInfo_GL_QCOM_render_sRGB_R8_RG8 (void) +{ + glewPrintExt("GL_QCOM_render_sRGB_R8_RG8", GLEW_QCOM_render_sRGB_R8_RG8, glewIsSupported("GL_QCOM_render_sRGB_R8_RG8"), glewGetExtension("GL_QCOM_render_sRGB_R8_RG8")); +} + +#endif /* GL_QCOM_render_sRGB_R8_RG8 */ + +#ifdef GL_QCOM_render_shared_exponent + +static void _glewInfo_GL_QCOM_render_shared_exponent (void) +{ + glewPrintExt("GL_QCOM_render_shared_exponent", GLEW_QCOM_render_shared_exponent, glewIsSupported("GL_QCOM_render_shared_exponent"), glewGetExtension("GL_QCOM_render_shared_exponent")); +} + +#endif /* GL_QCOM_render_shared_exponent */ + #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent (void) @@ -10218,6 +10522,17 @@ static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate (void) #endif /* GL_QCOM_shader_framebuffer_fetch_rate */ +#ifdef GL_QCOM_shading_rate + +static void _glewInfo_GL_QCOM_shading_rate (void) +{ + GLboolean fi = glewPrintExt("GL_QCOM_shading_rate", GLEW_QCOM_shading_rate, glewIsSupported("GL_QCOM_shading_rate"), glewGetExtension("GL_QCOM_shading_rate")); + + glewInfoFunc(fi, "glShadingRateQCOM", glShadingRateQCOM == NULL); +} + +#endif /* GL_QCOM_shading_rate */ + #ifdef GL_QCOM_texture_foveated static void _glewInfo_GL_QCOM_texture_foveated (void) @@ -10229,6 +10544,15 @@ static void _glewInfo_GL_QCOM_texture_foveated (void) #endif /* GL_QCOM_texture_foveated */ +#ifdef GL_QCOM_texture_foveated2 + +static void _glewInfo_GL_QCOM_texture_foveated2 (void) +{ + glewPrintExt("GL_QCOM_texture_foveated2", GLEW_QCOM_texture_foveated2, glewIsSupported("GL_QCOM_texture_foveated2"), glewGetExtension("GL_QCOM_texture_foveated2")); +} + +#endif /* GL_QCOM_texture_foveated2 */ + #ifdef GL_QCOM_texture_foveated_subsampled_layout static void _glewInfo_GL_QCOM_texture_foveated_subsampled_layout (void) @@ -10238,6 +10562,15 @@ static void _glewInfo_GL_QCOM_texture_foveated_subsampled_layout (void) #endif /* GL_QCOM_texture_foveated_subsampled_layout */ +#ifdef GL_QCOM_texture_lod_bias + +static void _glewInfo_GL_QCOM_texture_lod_bias (void) +{ + glewPrintExt("GL_QCOM_texture_lod_bias", GLEW_QCOM_texture_lod_bias, glewIsSupported("GL_QCOM_texture_lod_bias"), glewGetExtension("GL_QCOM_texture_lod_bias")); +} + +#endif /* GL_QCOM_texture_lod_bias */ + #ifdef GL_QCOM_tiled_rendering static void _glewInfo_GL_QCOM_tiled_rendering (void) @@ -10259,6 +10592,15 @@ static void _glewInfo_GL_QCOM_writeonly_rendering (void) #endif /* GL_QCOM_writeonly_rendering */ +#ifdef GL_QCOM_ycbcr_degamma + +static void _glewInfo_GL_QCOM_ycbcr_degamma (void) +{ + glewPrintExt("GL_QCOM_ycbcr_degamma", GLEW_QCOM_ycbcr_degamma, glewIsSupported("GL_QCOM_ycbcr_degamma"), glewGetExtension("GL_QCOM_ycbcr_degamma")); +} + +#endif /* GL_QCOM_ycbcr_degamma */ + #ifdef GL_REGAL_ES1_0_compatibility static void _glewInfo_GL_REGAL_ES1_0_compatibility (void) @@ -11873,6 +12215,15 @@ static void _glewInfo_EGL_ANDROID_recordable (void) #endif /* EGL_ANDROID_recordable */ +#ifdef EGL_ANDROID_telemetry_hint + +static void _glewInfo_EGL_ANDROID_telemetry_hint (void) +{ + glewPrintExt("EGL_ANDROID_telemetry_hint", EGLEW_ANDROID_telemetry_hint, eglewIsSupported("EGL_ANDROID_telemetry_hint"), eglewGetExtension("EGL_ANDROID_telemetry_hint")); +} + +#endif /* EGL_ANDROID_telemetry_hint */ + #ifdef EGL_ANGLE_d3d_share_handle_client_buffer static void _glewInfo_EGL_ANGLE_d3d_share_handle_client_buffer (void) @@ -11911,6 +12262,17 @@ static void _glewInfo_EGL_ANGLE_surface_d3d_texture_2d_share_handle (void) #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */ +#ifdef EGL_ANGLE_sync_control_rate + +static void _glewInfo_EGL_ANGLE_sync_control_rate (void) +{ + GLboolean fi = glewPrintExt("EGL_ANGLE_sync_control_rate", EGLEW_ANGLE_sync_control_rate, eglewIsSupported("EGL_ANGLE_sync_control_rate"), eglewGetExtension("EGL_ANGLE_sync_control_rate")); + + glewInfoFunc(fi, "eglGetMscRateANGLE", eglGetMscRateANGLE == NULL); +} + +#endif /* EGL_ANGLE_sync_control_rate */ + #ifdef EGL_ANGLE_window_fixed_size static void _glewInfo_EGL_ANGLE_window_fixed_size (void) @@ -12002,6 +12364,15 @@ static void _glewInfo_EGL_EXT_compositor (void) #endif /* EGL_EXT_compositor */ +#ifdef EGL_EXT_config_select_group + +static void _glewInfo_EGL_EXT_config_select_group (void) +{ + glewPrintExt("EGL_EXT_config_select_group", EGLEW_EXT_config_select_group, eglewIsSupported("EGL_EXT_config_select_group"), eglewGetExtension("EGL_EXT_config_select_group")); +} + +#endif /* EGL_EXT_config_select_group */ + #ifdef EGL_EXT_create_context_robustness static void _glewInfo_EGL_EXT_create_context_robustness (void) @@ -12029,6 +12400,15 @@ static void _glewInfo_EGL_EXT_device_drm (void) #endif /* EGL_EXT_device_drm */ +#ifdef EGL_EXT_device_drm_render_node + +static void _glewInfo_EGL_EXT_device_drm_render_node (void) +{ + glewPrintExt("EGL_EXT_device_drm_render_node", EGLEW_EXT_device_drm_render_node, eglewIsSupported("EGL_EXT_device_drm_render_node"), eglewGetExtension("EGL_EXT_device_drm_render_node")); +} + +#endif /* EGL_EXT_device_drm_render_node */ + #ifdef EGL_EXT_device_enumeration static void _glewInfo_EGL_EXT_device_enumeration (void) @@ -12049,6 +12429,17 @@ static void _glewInfo_EGL_EXT_device_openwf (void) #endif /* EGL_EXT_device_openwf */ +#ifdef EGL_EXT_device_persistent_id + +static void _glewInfo_EGL_EXT_device_persistent_id (void) +{ + GLboolean fi = glewPrintExt("EGL_EXT_device_persistent_id", EGLEW_EXT_device_persistent_id, eglewIsSupported("EGL_EXT_device_persistent_id"), eglewGetExtension("EGL_EXT_device_persistent_id")); + + glewInfoFunc(fi, "eglQueryDeviceBinaryEXT", eglQueryDeviceBinaryEXT == NULL); +} + +#endif /* EGL_EXT_device_persistent_id */ + #ifdef EGL_EXT_device_query static void _glewInfo_EGL_EXT_device_query (void) @@ -12062,6 +12453,44 @@ static void _glewInfo_EGL_EXT_device_query (void) #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_device_query_name + +static void _glewInfo_EGL_EXT_device_query_name (void) +{ + glewPrintExt("EGL_EXT_device_query_name", EGLEW_EXT_device_query_name, eglewIsSupported("EGL_EXT_device_query_name"), eglewGetExtension("EGL_EXT_device_query_name")); +} + +#endif /* EGL_EXT_device_query_name */ + +#ifdef EGL_EXT_display_alloc + +static void _glewInfo_EGL_EXT_display_alloc (void) +{ + GLboolean fi = glewPrintExt("EGL_EXT_display_alloc", EGLEW_EXT_display_alloc, eglewIsSupported("EGL_EXT_display_alloc"), eglewGetExtension("EGL_EXT_display_alloc")); + + glewInfoFunc(fi, "eglDestroyDisplayEXT", eglDestroyDisplayEXT == NULL); +} + +#endif /* EGL_EXT_display_alloc */ + +#ifdef EGL_EXT_explicit_device + +static void _glewInfo_EGL_EXT_explicit_device (void) +{ + glewPrintExt("EGL_EXT_explicit_device", EGLEW_EXT_explicit_device, eglewIsSupported("EGL_EXT_explicit_device"), eglewGetExtension("EGL_EXT_explicit_device")); +} + +#endif /* EGL_EXT_explicit_device */ + +#ifdef EGL_EXT_gl_colorspace_bt2020_hlg + +static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_hlg (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_bt2020_hlg", EGLEW_EXT_gl_colorspace_bt2020_hlg, eglewIsSupported("EGL_EXT_gl_colorspace_bt2020_hlg"), eglewGetExtension("EGL_EXT_gl_colorspace_bt2020_hlg")); +} + +#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */ + #ifdef EGL_EXT_gl_colorspace_bt2020_linear static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear (void) @@ -12258,6 +12687,24 @@ static void _glewInfo_EGL_EXT_platform_x11 (void) #endif /* EGL_EXT_platform_x11 */ +#ifdef EGL_EXT_platform_xcb + +static void _glewInfo_EGL_EXT_platform_xcb (void) +{ + glewPrintExt("EGL_EXT_platform_xcb", EGLEW_EXT_platform_xcb, eglewIsSupported("EGL_EXT_platform_xcb"), eglewGetExtension("EGL_EXT_platform_xcb")); +} + +#endif /* EGL_EXT_platform_xcb */ + +#ifdef EGL_EXT_present_opaque + +static void _glewInfo_EGL_EXT_present_opaque (void) +{ + glewPrintExt("EGL_EXT_present_opaque", EGLEW_EXT_present_opaque, eglewIsSupported("EGL_EXT_present_opaque"), eglewGetExtension("EGL_EXT_present_opaque")); +} + +#endif /* EGL_EXT_present_opaque */ + #ifdef EGL_EXT_protected_content static void _glewInfo_EGL_EXT_protected_content (void) @@ -12276,6 +12723,15 @@ static void _glewInfo_EGL_EXT_protected_surface (void) #endif /* EGL_EXT_protected_surface */ +#ifdef EGL_EXT_query_reset_notification_strategy + +static void _glewInfo_EGL_EXT_query_reset_notification_strategy (void) +{ + glewPrintExt("EGL_EXT_query_reset_notification_strategy", EGLEW_EXT_query_reset_notification_strategy, eglewIsSupported("EGL_EXT_query_reset_notification_strategy"), eglewGetExtension("EGL_EXT_query_reset_notification_strategy")); +} + +#endif /* EGL_EXT_query_reset_notification_strategy */ + #ifdef EGL_EXT_stream_consumer_egloutput static void _glewInfo_EGL_EXT_stream_consumer_egloutput (void) @@ -12305,6 +12761,17 @@ static void _glewInfo_EGL_EXT_surface_SMPTE2086_metadata (void) #endif /* EGL_EXT_surface_SMPTE2086_metadata */ +#ifdef EGL_EXT_surface_compression + +static void _glewInfo_EGL_EXT_surface_compression (void) +{ + GLboolean fi = glewPrintExt("EGL_EXT_surface_compression", EGLEW_EXT_surface_compression, eglewIsSupported("EGL_EXT_surface_compression"), eglewGetExtension("EGL_EXT_surface_compression")); + + glewInfoFunc(fi, "eglQuerySupportedCompressionRatesEXT", eglQuerySupportedCompressionRatesEXT == NULL); +} + +#endif /* EGL_EXT_surface_compression */ + #ifdef EGL_EXT_swap_buffers_with_damage static void _glewInfo_EGL_EXT_swap_buffers_with_damage (void) @@ -12993,6 +13460,29 @@ static void _glewInfo_EGL_NV_robustness_video_memory_purge (void) #endif /* EGL_NV_robustness_video_memory_purge */ +#ifdef EGL_NV_stream_consumer_eglimage + +static void _glewInfo_EGL_NV_stream_consumer_eglimage (void) +{ + GLboolean fi = glewPrintExt("EGL_NV_stream_consumer_eglimage", EGLEW_NV_stream_consumer_eglimage, eglewIsSupported("EGL_NV_stream_consumer_eglimage"), eglewGetExtension("EGL_NV_stream_consumer_eglimage")); + + glewInfoFunc(fi, "eglQueryStreamConsumerEventNV", eglQueryStreamConsumerEventNV == NULL); + glewInfoFunc(fi, "eglStreamAcquireImageNV", eglStreamAcquireImageNV == NULL); + glewInfoFunc(fi, "eglStreamImageConsumerConnectNV", eglStreamImageConsumerConnectNV == NULL); + glewInfoFunc(fi, "eglStreamReleaseImageNV", eglStreamReleaseImageNV == NULL); +} + +#endif /* EGL_NV_stream_consumer_eglimage */ + +#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib + +static void _glewInfo_EGL_NV_stream_consumer_eglimage_use_scanout_attrib (void) +{ + glewPrintExt("EGL_NV_stream_consumer_eglimage_use_scanout_attrib", EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib, eglewIsSupported("EGL_NV_stream_consumer_eglimage_use_scanout_attrib"), eglewGetExtension("EGL_NV_stream_consumer_eglimage_use_scanout_attrib")); +} + +#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */ + #ifdef EGL_NV_stream_consumer_gltexture_yuv static void _glewInfo_EGL_NV_stream_consumer_gltexture_yuv (void) @@ -13213,6 +13703,24 @@ static void _glewInfo_EGL_NV_triple_buffer (void) #endif /* EGL_NV_triple_buffer */ +#ifdef EGL_QNX_image_native_buffer + +static void _glewInfo_EGL_QNX_image_native_buffer (void) +{ + glewPrintExt("EGL_QNX_image_native_buffer", EGLEW_QNX_image_native_buffer, eglewIsSupported("EGL_QNX_image_native_buffer"), eglewGetExtension("EGL_QNX_image_native_buffer")); +} + +#endif /* EGL_QNX_image_native_buffer */ + +#ifdef EGL_QNX_platform_screen + +static void _glewInfo_EGL_QNX_platform_screen (void) +{ + glewPrintExt("EGL_QNX_platform_screen", EGLEW_QNX_platform_screen, eglewIsSupported("EGL_QNX_platform_screen"), eglewGetExtension("EGL_QNX_platform_screen")); +} + +#endif /* EGL_QNX_platform_screen */ + #ifdef EGL_TIZEN_image_native_buffer static void _glewInfo_EGL_TIZEN_image_native_buffer (void) @@ -14183,6 +14691,15 @@ static void _glewInfo_GLX_EXT_framebuffer_sRGB (void) #endif /* GLX_EXT_framebuffer_sRGB */ +#ifdef GLX_EXT_get_drawable_type + +static void _glewInfo_GLX_EXT_get_drawable_type (void) +{ + glewPrintExt("GLX_EXT_get_drawable_type", GLXEW_EXT_get_drawable_type, glxewIsSupported("GLX_EXT_get_drawable_type"), glxewGetExtension("GLX_EXT_get_drawable_type")); +} + +#endif /* GLX_EXT_get_drawable_type */ + #ifdef GLX_EXT_import_context static void _glewInfo_GLX_EXT_import_context (void) @@ -15574,6 +16091,9 @@ static void glewInfo (void) #ifdef GL_ARM_rgba8 _glewInfo_GL_ARM_rgba8(); #endif /* GL_ARM_rgba8 */ +#ifdef GL_ARM_shader_core_properties + _glewInfo_GL_ARM_shader_core_properties(); +#endif /* GL_ARM_shader_core_properties */ #ifdef GL_ARM_shader_framebuffer_fetch _glewInfo_GL_ARM_shader_framebuffer_fetch(); #endif /* GL_ARM_shader_framebuffer_fetch */ @@ -15667,6 +16187,9 @@ static void glewInfo (void) #ifdef GL_EXT_EGL_image_storage _glewInfo_GL_EXT_EGL_image_storage(); #endif /* GL_EXT_EGL_image_storage */ +#ifdef GL_EXT_EGL_image_storage_compression + _glewInfo_GL_EXT_EGL_image_storage_compression(); +#endif /* GL_EXT_EGL_image_storage_compression */ #ifdef GL_EXT_EGL_sync _glewInfo_GL_EXT_EGL_sync(); #endif /* GL_EXT_EGL_sync */ @@ -15814,9 +16337,21 @@ static void glewInfo (void) #ifdef GL_EXT_fragment_lighting _glewInfo_GL_EXT_fragment_lighting(); #endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_fragment_shading_rate + _glewInfo_GL_EXT_fragment_shading_rate(); +#endif /* GL_EXT_fragment_shading_rate */ +#ifdef GL_EXT_fragment_shading_rate_attachment + _glewInfo_GL_EXT_fragment_shading_rate_attachment(); +#endif /* GL_EXT_fragment_shading_rate_attachment */ +#ifdef GL_EXT_fragment_shading_rate_primitive + _glewInfo_GL_EXT_fragment_shading_rate_primitive(); +#endif /* GL_EXT_fragment_shading_rate_primitive */ #ifdef GL_EXT_framebuffer_blit _glewInfo_GL_EXT_framebuffer_blit(); #endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_blit_layers + _glewInfo_GL_EXT_framebuffer_blit_layers(); +#endif /* GL_EXT_framebuffer_blit_layers */ #ifdef GL_EXT_framebuffer_multisample _glewInfo_GL_EXT_framebuffer_multisample(); #endif /* GL_EXT_framebuffer_multisample */ @@ -15880,6 +16415,9 @@ static void glewInfo (void) #ifdef GL_EXT_memory_object_win32 _glewInfo_GL_EXT_memory_object_win32(); #endif /* GL_EXT_memory_object_win32 */ +#ifdef GL_EXT_mesh_shader + _glewInfo_GL_EXT_mesh_shader(); +#endif /* GL_EXT_mesh_shader */ #ifdef GL_EXT_misc_attribute _glewInfo_GL_EXT_misc_attribute(); #endif /* GL_EXT_misc_attribute */ @@ -16000,12 +16538,18 @@ static void glewInfo (void) #ifdef GL_EXT_semaphore_win32 _glewInfo_GL_EXT_semaphore_win32(); #endif /* GL_EXT_semaphore_win32 */ +#ifdef GL_EXT_separate_depth_stencil + _glewInfo_GL_EXT_separate_depth_stencil(); +#endif /* GL_EXT_separate_depth_stencil */ #ifdef GL_EXT_separate_shader_objects _glewInfo_GL_EXT_separate_shader_objects(); #endif /* GL_EXT_separate_shader_objects */ #ifdef GL_EXT_separate_specular_color _glewInfo_GL_EXT_separate_specular_color(); #endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shader_clock + _glewInfo_GL_EXT_shader_clock(); +#endif /* GL_EXT_shader_clock */ #ifdef GL_EXT_shader_framebuffer_fetch _glewInfo_GL_EXT_shader_framebuffer_fetch(); #endif /* GL_EXT_shader_framebuffer_fetch */ @@ -16039,9 +16583,18 @@ static void glewInfo (void) #ifdef GL_EXT_shader_pixel_local_storage2 _glewInfo_GL_EXT_shader_pixel_local_storage2(); #endif /* GL_EXT_shader_pixel_local_storage2 */ +#ifdef GL_EXT_shader_realtime_clock + _glewInfo_GL_EXT_shader_realtime_clock(); +#endif /* GL_EXT_shader_realtime_clock */ +#ifdef GL_EXT_shader_samples_identical + _glewInfo_GL_EXT_shader_samples_identical(); +#endif /* GL_EXT_shader_samples_identical */ #ifdef GL_EXT_shader_texture_lod _glewInfo_GL_EXT_shader_texture_lod(); #endif /* GL_EXT_shader_texture_lod */ +#ifdef GL_EXT_shader_texture_samples + _glewInfo_GL_EXT_shader_texture_samples(); +#endif /* GL_EXT_shader_texture_samples */ #ifdef GL_EXT_shadow_funcs _glewInfo_GL_EXT_shadow_funcs(); #endif /* GL_EXT_shadow_funcs */ @@ -16207,6 +16760,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_storage _glewInfo_GL_EXT_texture_storage(); #endif /* GL_EXT_texture_storage */ +#ifdef GL_EXT_texture_storage_compression + _glewInfo_GL_EXT_texture_storage_compression(); +#endif /* GL_EXT_texture_storage_compression */ #ifdef GL_EXT_texture_swizzle _glewInfo_GL_EXT_texture_swizzle(); #endif /* GL_EXT_texture_swizzle */ @@ -16273,6 +16829,12 @@ static void glewInfo (void) #ifdef GL_HP_texture_lighting _glewInfo_GL_HP_texture_lighting(); #endif /* GL_HP_texture_lighting */ +#ifdef GL_HUAWEI_program_binary + _glewInfo_GL_HUAWEI_program_binary(); +#endif /* GL_HUAWEI_program_binary */ +#ifdef GL_HUAWEI_shader_binary + _glewInfo_GL_HUAWEI_shader_binary(); +#endif /* GL_HUAWEI_shader_binary */ #ifdef GL_IBM_cull_vertex _glewInfo_GL_IBM_cull_vertex(); #endif /* GL_IBM_cull_vertex */ @@ -16303,6 +16865,9 @@ static void glewInfo (void) #ifdef GL_IMG_program_binary _glewInfo_GL_IMG_program_binary(); #endif /* GL_IMG_program_binary */ +#ifdef GL_IMG_pvric_end_to_end_signature + _glewInfo_GL_IMG_pvric_end_to_end_signature(); +#endif /* GL_IMG_pvric_end_to_end_signature */ #ifdef GL_IMG_read_format _glewInfo_GL_IMG_read_format(); #endif /* GL_IMG_read_format */ @@ -16321,6 +16886,9 @@ static void glewInfo (void) #ifdef GL_IMG_texture_filter_cubic _glewInfo_GL_IMG_texture_filter_cubic(); #endif /* GL_IMG_texture_filter_cubic */ +#ifdef GL_IMG_tile_region_protection + _glewInfo_GL_IMG_tile_region_protection(); +#endif /* GL_IMG_tile_region_protection */ #ifdef GL_INGR_color_clamp _glewInfo_GL_INGR_color_clamp(); #endif /* GL_INGR_color_clamp */ @@ -16396,9 +16964,18 @@ static void glewInfo (void) #ifdef GL_MESAX_texture_stack _glewInfo_GL_MESAX_texture_stack(); #endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_bgra + _glewInfo_GL_MESA_bgra(); +#endif /* GL_MESA_bgra */ +#ifdef GL_MESA_framebuffer_flip_x + _glewInfo_GL_MESA_framebuffer_flip_x(); +#endif /* GL_MESA_framebuffer_flip_x */ #ifdef GL_MESA_framebuffer_flip_y _glewInfo_GL_MESA_framebuffer_flip_y(); #endif /* GL_MESA_framebuffer_flip_y */ +#ifdef GL_MESA_framebuffer_swap_xy + _glewInfo_GL_MESA_framebuffer_swap_xy(); +#endif /* GL_MESA_framebuffer_swap_xy */ #ifdef GL_MESA_pack_invert _glewInfo_GL_MESA_pack_invert(); #endif /* GL_MESA_pack_invert */ @@ -16411,6 +16988,9 @@ static void glewInfo (void) #ifdef GL_MESA_shader_integer_functions _glewInfo_GL_MESA_shader_integer_functions(); #endif /* GL_MESA_shader_integer_functions */ +#ifdef GL_MESA_texture_const_bandwidth + _glewInfo_GL_MESA_texture_const_bandwidth(); +#endif /* GL_MESA_texture_const_bandwidth */ #ifdef GL_MESA_tile_raster_order _glewInfo_GL_MESA_tile_raster_order(); #endif /* GL_MESA_tile_raster_order */ @@ -16642,6 +17222,9 @@ static void glewInfo (void) #ifdef GL_NV_memory_attachment _glewInfo_GL_NV_memory_attachment(); #endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_memory_object_sparse + _glewInfo_GL_NV_memory_object_sparse(); +#endif /* GL_NV_memory_object_sparse */ #ifdef GL_NV_mesh_shader _glewInfo_GL_NV_mesh_shader(); #endif /* GL_NV_mesh_shader */ @@ -16702,6 +17285,9 @@ static void glewInfo (void) #ifdef GL_NV_primitive_restart _glewInfo_GL_NV_primitive_restart(); #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_primitive_shading_rate + _glewInfo_GL_NV_primitive_shading_rate(); +#endif /* GL_NV_primitive_shading_rate */ #ifdef GL_NV_query_resource_tag _glewInfo_GL_NV_query_resource_tag(); #endif /* GL_NV_query_resource_tag */ @@ -16849,12 +17435,18 @@ static void glewInfo (void) #ifdef GL_NV_texture_shader3 _glewInfo_GL_NV_texture_shader3(); #endif /* GL_NV_texture_shader3 */ +#ifdef GL_NV_timeline_semaphore + _glewInfo_GL_NV_timeline_semaphore(); +#endif /* GL_NV_timeline_semaphore */ #ifdef GL_NV_transform_feedback _glewInfo_GL_NV_transform_feedback(); #endif /* GL_NV_transform_feedback */ #ifdef GL_NV_transform_feedback2 _glewInfo_GL_NV_transform_feedback2(); #endif /* GL_NV_transform_feedback2 */ +#ifdef GL_NV_uniform_buffer_std430_layout + _glewInfo_GL_NV_uniform_buffer_std430_layout(); +#endif /* GL_NV_uniform_buffer_std430_layout */ #ifdef GL_NV_uniform_buffer_unified_memory _glewInfo_GL_NV_uniform_buffer_unified_memory(); #endif /* GL_NV_uniform_buffer_unified_memory */ @@ -17134,30 +17726,54 @@ static void glewInfo (void) #ifdef GL_QCOM_extended_get2 _glewInfo_GL_QCOM_extended_get2(); #endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_frame_extrapolation + _glewInfo_GL_QCOM_frame_extrapolation(); +#endif /* GL_QCOM_frame_extrapolation */ #ifdef GL_QCOM_framebuffer_foveated _glewInfo_GL_QCOM_framebuffer_foveated(); #endif /* GL_QCOM_framebuffer_foveated */ +#ifdef GL_QCOM_motion_estimation + _glewInfo_GL_QCOM_motion_estimation(); +#endif /* GL_QCOM_motion_estimation */ #ifdef GL_QCOM_perfmon_global_mode _glewInfo_GL_QCOM_perfmon_global_mode(); #endif /* GL_QCOM_perfmon_global_mode */ +#ifdef GL_QCOM_render_sRGB_R8_RG8 + _glewInfo_GL_QCOM_render_sRGB_R8_RG8(); +#endif /* GL_QCOM_render_sRGB_R8_RG8 */ +#ifdef GL_QCOM_render_shared_exponent + _glewInfo_GL_QCOM_render_shared_exponent(); +#endif /* GL_QCOM_render_shared_exponent */ #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent(); #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ #ifdef GL_QCOM_shader_framebuffer_fetch_rate _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate(); #endif /* GL_QCOM_shader_framebuffer_fetch_rate */ +#ifdef GL_QCOM_shading_rate + _glewInfo_GL_QCOM_shading_rate(); +#endif /* GL_QCOM_shading_rate */ #ifdef GL_QCOM_texture_foveated _glewInfo_GL_QCOM_texture_foveated(); #endif /* GL_QCOM_texture_foveated */ +#ifdef GL_QCOM_texture_foveated2 + _glewInfo_GL_QCOM_texture_foveated2(); +#endif /* GL_QCOM_texture_foveated2 */ #ifdef GL_QCOM_texture_foveated_subsampled_layout _glewInfo_GL_QCOM_texture_foveated_subsampled_layout(); #endif /* GL_QCOM_texture_foveated_subsampled_layout */ +#ifdef GL_QCOM_texture_lod_bias + _glewInfo_GL_QCOM_texture_lod_bias(); +#endif /* GL_QCOM_texture_lod_bias */ #ifdef GL_QCOM_tiled_rendering _glewInfo_GL_QCOM_tiled_rendering(); #endif /* GL_QCOM_tiled_rendering */ #ifdef GL_QCOM_writeonly_rendering _glewInfo_GL_QCOM_writeonly_rendering(); #endif /* GL_QCOM_writeonly_rendering */ +#ifdef GL_QCOM_ycbcr_degamma + _glewInfo_GL_QCOM_ycbcr_degamma(); +#endif /* GL_QCOM_ycbcr_degamma */ #ifdef GL_REGAL_ES1_0_compatibility _glewInfo_GL_REGAL_ES1_0_compatibility(); #endif /* GL_REGAL_ES1_0_compatibility */ @@ -17725,7 +18341,7 @@ static void wglewInfo () #elif !defined(GLEW_EGL) && !defined(GLEW_OSMESA) /* _UNIX */ -static void glxewInfo () +static void glxewInfo (void) { #ifdef GLX_VERSION_1_2 _glewInfo_GLX_VERSION_1_2(); @@ -17802,6 +18418,9 @@ static void glxewInfo () #ifdef GLX_EXT_framebuffer_sRGB _glewInfo_GLX_EXT_framebuffer_sRGB(); #endif /* GLX_EXT_framebuffer_sRGB */ +#ifdef GLX_EXT_get_drawable_type + _glewInfo_GLX_EXT_get_drawable_type(); +#endif /* GLX_EXT_get_drawable_type */ #ifdef GLX_EXT_import_context _glewInfo_GLX_EXT_import_context(); #endif /* GLX_EXT_import_context */ @@ -17953,7 +18572,7 @@ static void glxewInfo () #elif defined(GLEW_EGL) -static void eglewInfo () +static void eglewInfo (void) { #ifdef EGL_VERSION_1_0 _glewInfo_EGL_VERSION_1_0(); @@ -18006,6 +18625,9 @@ static void eglewInfo () #ifdef EGL_ANDROID_recordable _glewInfo_EGL_ANDROID_recordable(); #endif /* EGL_ANDROID_recordable */ +#ifdef EGL_ANDROID_telemetry_hint + _glewInfo_EGL_ANDROID_telemetry_hint(); +#endif /* EGL_ANDROID_telemetry_hint */ #ifdef EGL_ANGLE_d3d_share_handle_client_buffer _glewInfo_EGL_ANGLE_d3d_share_handle_client_buffer(); #endif /* EGL_ANGLE_d3d_share_handle_client_buffer */ @@ -18018,6 +18640,9 @@ static void eglewInfo () #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle _glewInfo_EGL_ANGLE_surface_d3d_texture_2d_share_handle(); #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */ +#ifdef EGL_ANGLE_sync_control_rate + _glewInfo_EGL_ANGLE_sync_control_rate(); +#endif /* EGL_ANGLE_sync_control_rate */ #ifdef EGL_ANGLE_window_fixed_size _glewInfo_EGL_ANGLE_window_fixed_size(); #endif /* EGL_ANGLE_window_fixed_size */ @@ -18045,6 +18670,9 @@ static void eglewInfo () #ifdef EGL_EXT_compositor _glewInfo_EGL_EXT_compositor(); #endif /* EGL_EXT_compositor */ +#ifdef EGL_EXT_config_select_group + _glewInfo_EGL_EXT_config_select_group(); +#endif /* EGL_EXT_config_select_group */ #ifdef EGL_EXT_create_context_robustness _glewInfo_EGL_EXT_create_context_robustness(); #endif /* EGL_EXT_create_context_robustness */ @@ -18054,15 +18682,33 @@ static void eglewInfo () #ifdef EGL_EXT_device_drm _glewInfo_EGL_EXT_device_drm(); #endif /* EGL_EXT_device_drm */ +#ifdef EGL_EXT_device_drm_render_node + _glewInfo_EGL_EXT_device_drm_render_node(); +#endif /* EGL_EXT_device_drm_render_node */ #ifdef EGL_EXT_device_enumeration _glewInfo_EGL_EXT_device_enumeration(); #endif /* EGL_EXT_device_enumeration */ #ifdef EGL_EXT_device_openwf _glewInfo_EGL_EXT_device_openwf(); #endif /* EGL_EXT_device_openwf */ +#ifdef EGL_EXT_device_persistent_id + _glewInfo_EGL_EXT_device_persistent_id(); +#endif /* EGL_EXT_device_persistent_id */ #ifdef EGL_EXT_device_query _glewInfo_EGL_EXT_device_query(); #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_device_query_name + _glewInfo_EGL_EXT_device_query_name(); +#endif /* EGL_EXT_device_query_name */ +#ifdef EGL_EXT_display_alloc + _glewInfo_EGL_EXT_display_alloc(); +#endif /* EGL_EXT_display_alloc */ +#ifdef EGL_EXT_explicit_device + _glewInfo_EGL_EXT_explicit_device(); +#endif /* EGL_EXT_explicit_device */ +#ifdef EGL_EXT_gl_colorspace_bt2020_hlg + _glewInfo_EGL_EXT_gl_colorspace_bt2020_hlg(); +#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */ #ifdef EGL_EXT_gl_colorspace_bt2020_linear _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear(); #endif /* EGL_EXT_gl_colorspace_bt2020_linear */ @@ -18123,12 +18769,21 @@ static void eglewInfo () #ifdef EGL_EXT_platform_x11 _glewInfo_EGL_EXT_platform_x11(); #endif /* EGL_EXT_platform_x11 */ +#ifdef EGL_EXT_platform_xcb + _glewInfo_EGL_EXT_platform_xcb(); +#endif /* EGL_EXT_platform_xcb */ +#ifdef EGL_EXT_present_opaque + _glewInfo_EGL_EXT_present_opaque(); +#endif /* EGL_EXT_present_opaque */ #ifdef EGL_EXT_protected_content _glewInfo_EGL_EXT_protected_content(); #endif /* EGL_EXT_protected_content */ #ifdef EGL_EXT_protected_surface _glewInfo_EGL_EXT_protected_surface(); #endif /* EGL_EXT_protected_surface */ +#ifdef EGL_EXT_query_reset_notification_strategy + _glewInfo_EGL_EXT_query_reset_notification_strategy(); +#endif /* EGL_EXT_query_reset_notification_strategy */ #ifdef EGL_EXT_stream_consumer_egloutput _glewInfo_EGL_EXT_stream_consumer_egloutput(); #endif /* EGL_EXT_stream_consumer_egloutput */ @@ -18138,6 +18793,9 @@ static void eglewInfo () #ifdef EGL_EXT_surface_SMPTE2086_metadata _glewInfo_EGL_EXT_surface_SMPTE2086_metadata(); #endif /* EGL_EXT_surface_SMPTE2086_metadata */ +#ifdef EGL_EXT_surface_compression + _glewInfo_EGL_EXT_surface_compression(); +#endif /* EGL_EXT_surface_compression */ #ifdef EGL_EXT_swap_buffers_with_damage _glewInfo_EGL_EXT_swap_buffers_with_damage(); #endif /* EGL_EXT_swap_buffers_with_damage */ @@ -18342,6 +19000,12 @@ static void eglewInfo () #ifdef EGL_NV_robustness_video_memory_purge _glewInfo_EGL_NV_robustness_video_memory_purge(); #endif /* EGL_NV_robustness_video_memory_purge */ +#ifdef EGL_NV_stream_consumer_eglimage + _glewInfo_EGL_NV_stream_consumer_eglimage(); +#endif /* EGL_NV_stream_consumer_eglimage */ +#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib + _glewInfo_EGL_NV_stream_consumer_eglimage_use_scanout_attrib(); +#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */ #ifdef EGL_NV_stream_consumer_gltexture_yuv _glewInfo_EGL_NV_stream_consumer_gltexture_yuv(); #endif /* EGL_NV_stream_consumer_gltexture_yuv */ @@ -18408,6 +19072,12 @@ static void eglewInfo () #ifdef EGL_NV_triple_buffer _glewInfo_EGL_NV_triple_buffer(); #endif /* EGL_NV_triple_buffer */ +#ifdef EGL_QNX_image_native_buffer + _glewInfo_EGL_QNX_image_native_buffer(); +#endif /* EGL_QNX_image_native_buffer */ +#ifdef EGL_QNX_platform_screen + _glewInfo_EGL_QNX_platform_screen(); +#endif /* EGL_QNX_platform_screen */ #ifdef EGL_TIZEN_image_native_buffer _glewInfo_EGL_TIZEN_image_native_buffer(); #endif /* EGL_TIZEN_image_native_buffer */ @@ -18617,7 +19287,6 @@ GLboolean glewCreateContext (struct createParams *params) EGLDeviceEXT devices[1]; EGLint numDevices; EGLSurface surface; - EGLint majorVersion, minorVersion; EGLint configAttribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 1, @@ -18651,6 +19320,8 @@ GLboolean glewCreateContext (struct createParams *params) PFNEGLMAKECURRENTPROC makeCurrent = NULL; PFNEGLCREATEPBUFFERSURFACEPROC createPbufferSurface = NULL; + (void) params; /* not used */ + /* Load necessary entry points */ queryDevices = (PFNEGLQUERYDEVICESEXTPROC) eglGetProcAddress("eglQueryDevicesEXT"); getPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYEXTPROC) eglGetProcAddress("eglGetPlatformDisplayEXT"); @@ -18721,7 +19392,7 @@ GLboolean glewCreateContext (struct createParams *params) return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { if (NULL != ctx) eglDestroyContext(display, ctx); } @@ -18736,20 +19407,22 @@ static GLubyte *osmPixels = NULL; GLboolean glewCreateContext (struct createParams *params) { + (void) params; /* not used */ + ctx = OSMesaCreateContext(OSMESA_RGBA, NULL); if (NULL == ctx) return GL_TRUE; if (NULL == osmPixels) { osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1); } - if (!OSMesaMakeCurrent(ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight)) + if (!OSMesaMakeCurrent(ctx, osmPixels, osmFormat, osmWidth, osmHeight)) { return GL_TRUE; } return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { if (NULL != ctx) OSMesaDestroyContext(ctx); } @@ -18834,7 +19507,7 @@ GLboolean glewCreateContext (struct createParams* params) return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { if (NULL != rc) wglMakeCurrent(NULL, NULL); if (NULL != rc) wglDeleteContext(rc); @@ -18892,7 +19565,7 @@ GLboolean glewCreateContext (struct createParams *params) return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { CGLSetCurrentContext(octx); CGLReleaseContext(ctx); @@ -18905,10 +19578,11 @@ void glewDestroyContext () GLboolean glewCreateContext (struct createParams *params) { /* TODO: Haiku: We need to call C++ code here */ + (void) params; /* not used */ return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { /* TODO: Haiku: We need to call C++ code here */ } @@ -19016,7 +19690,7 @@ GLboolean glewCreateContext (struct createParams *params) return GL_FALSE; } -void glewDestroyContext () +void glewDestroyContext (void) { if (NULL != dpy && NULL != ctx) glXDestroyContext(dpy, ctx); if (NULL != dpy && 0 != wnd) XDestroyWindow(dpy, wnd); diff --git a/src/visualinfo.c b/src/visualinfo.c index 6879f78..dad8a9e 100644 --- a/src/visualinfo.c +++ b/src/visualinfo.c @@ -4,7 +4,7 @@ ** Copyright (C) Nate Robins, 1997 ** Michael Wimmer, 1999 ** Milan Ikits, 2002-2008 -** Nigel Stewart, 2008-2019 +** Nigel Stewart, 2008-2025 ** ** visualinfo is a small utility that displays all available visuals, ** aka. pixelformats, in an OpenGL system along with renderer version @@ -36,6 +36,9 @@ #include #if defined(GLEW_OSMESA) #define GLAPI extern +#ifndef APIENTRY +#define APIENTRY +#endif #include #elif defined(GLEW_EGL) #include @@ -48,18 +51,6 @@ #include #endif -#ifdef GLEW_MX -GLEWContext _glewctx; -# define glewGetContext() (&_glewctx) -# ifdef _WIN32 -WGLEWContext _wglewctx; -# define wglewGetContext() (&_wglewctx) -# elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX) -GLXEWContext _glxewctx; -# define glxewGetContext() (&_glxewctx) -# endif -#endif /* GLEW_MX */ - typedef struct GLContextStruct { #if defined(GLEW_OSMESA) @@ -123,6 +114,13 @@ main (int argc, char** argv) return 1; } +#if defined(GLEW_EGL) + { + fprintf(stderr, "Error [main]: EGL not supported by visualinfo.\n"); + return 1; + } +#endif + /* ---------------------------------------------------------------------- */ /* create OpenGL rendering context */ InitContext(&ctx); @@ -136,16 +134,7 @@ main (int argc, char** argv) /* ---------------------------------------------------------------------- */ /* initialize GLEW */ glewExperimental = GL_TRUE; -#ifdef GLEW_MX - err = glewContextInit(glewGetContext()); -# ifdef _WIN32 - err = err || wglewContextInit(wglewGetContext()); -# elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX) - err = err || glxewContextInit(glxewGetContext()); -# endif -#else err = glewInit(); -#endif if (GLEW_OK != err) { fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err)); @@ -274,6 +263,7 @@ void PrintExtensions (const char* s) void VisualInfo (GLContext* ctx) { + (void) ctx; /* not used */ } #elif defined(_WIN32) @@ -1041,7 +1031,7 @@ GLboolean CreateContext (GLContext* ctx) { osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1); } - if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight)) + if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, osmFormat, osmWidth, osmHeight)) { return GL_TRUE; } @@ -1063,13 +1053,13 @@ void InitContext (GLContext* ctx) GLboolean CreateContext (GLContext* ctx) { + (void) ctx; /* not used */ return GL_FALSE; } void DestroyContext (GLContext* ctx) { - if (NULL == ctx) return; - return; + (void) ctx; /* not used */ } /* ------------------------------------------------------------------------ */