ソースを参照

Adds the remaining packages (For darwin) that are ready. (#7)

Packages were tested on darwin/mac/built for ios

Signed-off-by: lawsonamzn <[email protected]>
Nicholas Lawson 4 年 前
コミット
683c2af1a6
53 ファイル変更10180 行追加8 行削除
  1. 11 0
      package-system/.gitignore
  2. 33 0
      package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Linux
  3. 32 0
      package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Mac
  4. 27 0
      package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Windows
  5. 103 0
      package-system/DirectXShaderCompiler/build_config.json
  6. 41 0
      package-system/DirectXShaderCompiler/build_dxc_windows.cmd
  7. 87 0
      package-system/DirectXShaderCompiler/install_dxc_windows.cmd
  8. 55 0
      package-system/NvCloth/FindNvCloth.cmake
  9. 262 0
      package-system/NvCloth/build_package_image.py
  10. 308 0
      package-system/PhysX/Build-physx-profile-config.patch
  11. 84 0
      package-system/PhysX/FindPhysX.cmake.template
  12. 65 0
      package-system/PhysX/FindPhysX_ios.cmake.template
  13. 126 0
      package-system/PhysX/build_package_image.py
  14. 23 0
      package-system/SPIRVCross/FindSPIRVCross.cmake.Linux
  15. 24 0
      package-system/SPIRVCross/FindSPIRVCross.cmake.Mac
  16. 24 0
      package-system/SPIRVCross/FindSPIRVCross.cmake.Windows
  17. 101 0
      package-system/SPIRVCross/build_config.json
  18. 16 0
      package-system/glad-multiplatform/Findglad.cmake
  19. 6 0
      package-system/glad-multiplatform/PackageInfo.json
  20. 63 0
      package-system/glad-multiplatform/glad/LICENSE
  21. 19 0
      package-system/glad-multiplatform/glad/include/glad/egl.h
  22. 19 0
      package-system/glad-multiplatform/glad/include/glad/gl.h
  23. 19 0
      package-system/glad-multiplatform/glad/include/glad/gles2.h
  24. 1933 0
      package-system/glad-multiplatform/glad/include/glad/glx.h
  25. 1589 0
      package-system/glad-multiplatform/glad/include/glad/wgl.h
  26. 43 0
      package-system/googlebenchmark/FindGoogleBenchmark.cmake.template
  27. 38 0
      package-system/googlebenchmark/FindGoogleBenchmarkRelOnly.cmake.template
  28. 250 0
      package-system/googlebenchmark/benchmark-1.5.0.patch
  29. 208 0
      package-system/googlebenchmark/build_config.json
  30. 100 0
      package-system/googletest/Findgoogletest.cmake.template
  31. 80 0
      package-system/googletest/FindgoogletestRelOnly.cmake.template
  32. 154 0
      package-system/googletest/build_config.json
  33. 108 0
      package-system/googletest/googletest-release-1.8.1.patch
  34. 29 0
      package-system/libsamplerate/Findlibsamplerate.cmake.template
  35. 139 0
      package-system/libsamplerate/build_config.json
  36. 28 0
      package-system/mcpp/Findmcpp.cmake.template
  37. 398 0
      package-system/mcpp/get_and_build_mcpp.py
  38. 844 0
      package-system/mcpp/mcpp-2.7.2-az.2.patch
  39. 154 0
      package-system/mcpp/visualc.mak
  40. 1 0
      package-system/mikkelsen/.gitignore
  41. 31 0
      package-system/mikkelsen/CMakeLists.txt
  42. 17 0
      package-system/mikkelsen/LICENSE.txt
  43. 88 0
      package-system/mikkelsen/build_package_image.py
  44. 1966 0
      package-system/mikkelsen/mikktspace.cpp
  45. 143 0
      package-system/mikkelsen/mikktspace.h
  46. 42 0
      package-system/poly2tri/Findpoly2tri.cmake
  47. 29 0
      package-system/poly2tri/build-poly2tri-jhasse-repo.patch
  48. 85 0
      package-system/poly2tri/build_package_image.py
  49. 42 0
      package-system/v-hacd/Findv-hacd.cmake
  50. 79 0
      package-system/v-hacd/build_package_image.py
  51. 6 3
      package_build_list_host_darwin.json
  52. 4 1
      package_build_list_host_linux.json
  53. 4 4
      package_build_list_host_windows.json

+ 11 - 0
package-system/.gitignore

@@ -4,3 +4,14 @@ AwsIotDeviceSdkCpp-*
 Blast-*
 Crashpad-*
 etc2comp-*
+googlebenchmark-*
+googletest-*
+libsamplerate-*
+mcpp-*
+NvCloth-*
+PhysX-*
+poly2tri-*
+SPIRVCross-*
+DirectXShaderCompilerDxc-*
+v-hacd-*
+mikkelsen-*

+ 33 - 0
package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Linux

@@ -0,0 +1,33 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "DirectXShaderCompilerDxc")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/DirectXShaderCompiler")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+set($${MY_NAME}_LIB_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/lib)
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+set($${MY_NAME}_BIN_RUNTIME_DEPENDENCIES
+        $${$${MY_NAME}_BINARY_DIR}/dxc
+        $${$${MY_NAME}_BINARY_DIR}/dxc-3.7
+        )
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY "$${output_subfolder}/bin" FILES $${$${MY_NAME}_BIN_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_LIB_RUNTIME_DEPENDENCIES
+        $${$${MY_NAME}_LIB_DIR}/libdxcompiler.so
+        $${$${MY_NAME}_LIB_DIR}/libdxcompiler.so.3.7
+        )
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY "$${output_subfolder}/lib" FILES $${$${MY_NAME}_LIB_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 32 - 0
package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Mac

@@ -0,0 +1,32 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+set(MY_NAME "DirectXShaderCompilerDxc")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/DirectXShaderCompiler")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+set($${MY_NAME}_LIB_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/lib)
+	
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+set($${MY_NAME}_BIN_RUNTIME_DEPENDENCIES
+        $${$${MY_NAME}_BINARY_DIR}/dxc
+        $${$${MY_NAME}_BINARY_DIR}/dxc-3.7
+        )
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY "$${output_subfolder}/bin" FILES $${$${MY_NAME}_BIN_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_LIB_RUNTIME_DEPENDENCIES
+        $${$${MY_NAME}_LIB_DIR}/libdxcompiler.dylib
+        $${$${MY_NAME}_LIB_DIR}/libdxcompiler.3.7.dylib
+        )
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY "$${output_subfolder}/lib" FILES $${$${MY_NAME}_LIB_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 27 - 0
package-system/DirectXShaderCompiler/FindDirectXShaderCompilerDxc.cmake.Windows

@@ -0,0 +1,27 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "DirectXShaderCompilerDxc")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/DirectXShaderCompiler")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+set($${MY_NAME}_RUNTIME_DEPENDENCIES
+		$${$${MY_NAME}_BINARY_DIR}/Release/dxc.exe
+		$${$${MY_NAME}_BINARY_DIR}/Release/dxil.dll
+		$${$${MY_NAME}_BINARY_DIR}/Release/dxcompiler.dll)
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY $${output_subfolder} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+
+
+set($${MY_NAME}_FOUND True)

+ 103 - 0
package-system/DirectXShaderCompiler/build_config.json

@@ -0,0 +1,103 @@
+{
+   "git_url":"https://github.com/aws-lumberyard/DirectXShaderCompiler.git",
+   "git_tag":"release-1.6.2104-o3de",
+   "package_name":"DirectXShaderCompilerDxc",
+   "package_version":"1.6.2104-o3de-rev2",
+   "package_url":"https://github.com/aws-lumberyard/DirectXShaderCompiler",
+   "package_license":"NCSA",
+   "package_license_file":"LICENSE.TXT",
+   "cmake_find_target":"FindDirectXShaderCompilerDxc.cmake",
+   "Platforms":{
+      "Windows":{
+         "Windows":{
+            "cmake_find_template":"FindDirectXShaderCompilerDxc.cmake.Windows",
+            "custom_build_cmd": [
+               "build_dxc_windows.cmd"
+            ],
+            "custom_install_cmd": [
+               "install_dxc_windows.cmd"
+            ]
+         }
+      },
+      "Darwin":{
+         "Mac":{
+            "build_configs": ["Release"],
+            "cmake_find_template":"FindDirectXShaderCompilerDxc.cmake.Mac",
+            "cmake_generate_args":[
+               "-DCMAKE_BUILD_TYPE=Release",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Release\"",
+               "-DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON",
+               "-DLLVM_APPEND_VC_REV:BOOL=ON",
+               "-DLLVM_DEFAULT_TARGET_TRIPLE:STRING=dxil-ms-dx",
+               "-DLLVM_ENABLE_EH:BOOL=ON",
+               "-DLLVM_ENABLE_RTTI:BOOL=ON",
+               "-DLLVM_INCLUDE_DOCS:BOOL=OFF",
+               "-DLLVM_INCLUDE_EXAMPLES:BOOL=OFF",
+               "-DLLVM_INCLUDE_TESTS:BOOL=OFF",
+               "-DLLVM_OPTIMIZED_TABLEGEN:BOOL=OFF",
+               "-DLLVM_REQUIRES_EH:BOOL=ON",
+               "-DLLVM_REQUIRES_RTTI:BOOL=ON",
+               "-DLLVM_TARGETS_TO_BUILD:STRING=None",
+               "-DLIBCLANG_BUILD_STATIC:BOOL=ON",
+               "-DCLANG_BUILD_EXAMPLES:BOOL=OFF",
+               "-DCLANG_CL:BOOL=OFF",
+               "-DCLANG_ENABLE_ARCMT:BOOL=OFF",
+               "-DCLANG_ENABLE_STATIC_ANALYZER:BOOL=OFF",
+               "-DCLANG_INCLUDE_TESTS:BOOL=OFF",
+               "-DHLSL_INCLUDE_TESTS:BOOL=ON",
+               "-DENABLE_SPIRV_CODEGEN:BOOL=ON",
+               "-DSPIRV_BUILD_TESTS:BOOL=ON"
+            ],
+            "cmake_build_args":[
+               "-j",
+               "8"
+            ],
+            "cmake_install_filter":[
+               "bin/*",
+               "lib/*.dylib"
+            ]
+         }
+      },
+      "Linux":{
+         "Linux":{
+            "build_configs": ["Release"],
+            "cmake_find_template":"FindDirectXShaderCompilerDxc.cmake.Linux",
+            "cmake_generate_args":[
+               "-GNinja",
+               "-DCMAKE_BUILD_TYPE=Release",
+               "-DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON",
+               "-DLLVM_APPEND_VC_REV:BOOL=ON",
+               "-DLLVM_DEFAULT_TARGET_TRIPLE:STRING=dxil-ms-dx",
+               "-DLLVM_ENABLE_EH:BOOL=ON",
+               "-DLLVM_ENABLE_RTTI:BOOL=ON",
+               "-DLLVM_INCLUDE_DOCS:BOOL=OFF",
+               "-DLLVM_INCLUDE_EXAMPLES:BOOL=OFF",
+               "-DLLVM_INCLUDE_TESTS:BOOL=OFF",
+               "-DLLVM_OPTIMIZED_TABLEGEN:BOOL=OFF",
+               "-DLLVM_REQUIRES_EH:BOOL=ON",
+               "-DLLVM_REQUIRES_RTTI:BOOL=ON",
+               "-DLLVM_TARGETS_TO_BUILD:STRING=None",
+               "-DLIBCLANG_BUILD_STATIC:BOOL=ON",
+               "-DCLANG_BUILD_EXAMPLES:BOOL=OFF",
+               "-DCLANG_CL:BOOL=OFF",
+               "-DCLANG_ENABLE_ARCMT:BOOL=OFF",
+               "-DCLANG_ENABLE_STATIC_ANALYZER:BOOL=OFF",
+               "-DCLANG_INCLUDE_TESTS:BOOL=OFF",
+               "-DHLSL_INCLUDE_TESTS:BOOL=ON",
+               "-DENABLE_SPIRV_CODEGEN:BOOL=ON",
+               "-DSPIRV_BUILD_TESTS:BOOL=ON"
+            ],
+            "cmake_build_args":[
+               "-j",
+               "2"
+            ],
+            "cmake_install_filter":[
+               "bin/*",
+               "lib/*.so",
+               "lib/*.so.*"
+            ]         
+         }
+      }
+   }
+}

+ 41 - 0
package-system/DirectXShaderCompiler/build_dxc_windows.cmd

@@ -0,0 +1,41 @@
+@echo off
+REM
+REM 
+REM Copyright (c) Contributors to the Open 3D Engine Project.
+REM For complete copyright and license terms please see the LICENSE at the root of this distribution.
+REM 
+REM SPDX-License-Identifier: Apache-2.0 OR MIT
+REM 
+REM 
+
+SET SRC_PATH=temp\src
+SET BLD_PATH=temp\build
+SET HCT_PATH=temp\src\utils\hct
+
+SET HCT_START=%HCT_PATH%\\hctstart.cmd
+
+REM Initialize the environment
+call %HCT_START% %SRC_PATH% %BLD_PATH%
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO "%HCT_START% Command Failed"
+    exit /b 1
+)
+
+REM Make sure TAEF is installed
+call utils\hct\hctgettaef.py
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO "utils\hct\hctgettaef.py Command Failed"
+    exit /b 1
+)
+
+REM Run the build for Release
+call utils\hct\hctbuild.cmd -rel -x64 -vs2019 -spirv
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO "Building Release with hctbuild.cmd -rel -x64 -vs2019 Failed"
+    exit /b 1
+)
+
+ECHO Custom Build for DirectXShaderCompiler finished successfully
+exit /b 0
+
+

+ 87 - 0
package-system/DirectXShaderCompiler/install_dxc_windows.cmd

@@ -0,0 +1,87 @@
+ @echo off
+
+REM Copyright (c) Contributors to the Open 3D Engine Project.
+REM For complete copyright and license terms please see the LICENSE at the root of this distribution.
+REM 
+REM SPDX-License-Identifier: Apache-2.0 OR MIT
+REM
+
+SET BLD_PATH=temp\build
+SET SRC_PATH=temp\src
+SET BIN_PATH=%TARGET_INSTALL_ROOT%\bin
+
+
+REM Locate the Windows Kit 10 installation path to get the dxil.dll located inside the Redist/D3D folder
+set REG_QUERY=REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Microsoft SDKs\Windows\v10.0"
+set WINKIT_ROOT=
+for /F "tokens=1,2*" %%A in ('%REG_QUERY% /v InstallationFolder') do (
+  if "%%A"=="InstallationFolder" (
+    set WINKIT_ROOT=%%C
+  )
+)
+set DXIL_PATH="%WINKIT_ROOT%\Redist\D3D\x64\dxil.dll"
+IF NOT EXIST %DXIL_PATH% (
+    echo Unable to find dxil.dll. Make sure that Windows Kit is installed
+    exit /b 1
+)
+
+
+mkdir %BIN_PATH%\Release
+
+echo Copying LICENSE.TXT to %TARGET_INSTALL_ROOT%
+copy /Y %SRC_PATH%\\LICENSE.TXT %TARGET_INSTALL_ROOT%\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy LICENSE.TXT
+    exit /b 1
+)
+
+mkdir %BIN_PATH%\Debug
+echo Copying %BLD_PATH%\Debug\bin\dxc.exe to %BIN_PATH%\Debug\
+copy /Y %BLD_PATH%\Debug\bin\dxc.exe %BIN_PATH%\Debug\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %BLD_PATH%\Debug\bin\dxc.exe
+    exit /b 1
+)
+
+echo Copying %BLD_PATH%\Debug\bin\dxcompiler.dll to %BIN_PATH%\Debug\
+copy /Y %BLD_PATH%\Debug\bin\dxcompiler.dll %BIN_PATH%\Debug\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %BLD_PATH%\Debug\bin\dxcompiler.dll
+    exit /b 1
+)
+
+echo Copying %DXIL_PATH% to %BIN_PATH%\Debug\
+copy /Y %DXIL_PATH% %BIN_PATH%\Debug\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %DXIL_PATH%
+    exit /b 1
+)
+
+mkdir %BIN_PATH%\Release
+
+echo Copying %BLD_PATH%\Release\bin\dxc.exe to %BIN_PATH%\Release\
+copy /Y %BLD_PATH%\Release\bin\dxc.exe %BIN_PATH%\Release\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %BLD_PATH%\Release\bin\dxc.exe
+    exit /b 1
+)
+
+ECHO Copying %BLD_PATH%\Release\bin\dxcompiler.dll to %BIN_PATH%\\Release\
+copy /Y %BLD_PATH%\Release\bin\dxcompiler.dll %BIN_PATH%\\Release\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %BLD_PATH%\Release\bin\dxcompiler.dll
+    exit /b 1
+)
+
+ECHO Copying DXIL_PATH to %BIN_PATH%\Release\
+copy /Y %DXIL_PATH% %BIN_PATH%\Release\
+IF %ERRORLEVEL% NEQ 0 (
+    ECHO Unable to copy %DXIL_PATH%
+    exit /b 1
+)
+
+exit /b 0
+
+
+
+

+ 55 - 0
package-system/NvCloth/FindNvCloth.cmake

@@ -0,0 +1,55 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "NvCloth")
+set(TARGET_WITH_NAMESPACE "3rdParty::${MY_NAME}")
+if (TARGET ${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(_PACKAGE_DIR ${CMAKE_CURRENT_LIST_DIR}/NvCloth)
+
+set(${MY_NAME}_INCLUDE_DIR ${_PACKAGE_DIR}/NvCloth/include 
+                           ${_PACKAGE_DIR}/NvCloth/extensions/include
+                           ${_PACKAGE_DIR}/PxShared/include)
+
+# It's important to define NV_CLOTH_IMPORT and PX_CALL_CONV without
+# giving them a value, otherwise they will cause compilation issues
+# because they are used as prefix for classes and functions.
+set(${MY_NAME}_COMPILE_DEFINITIONS NV_CLOTH_IMPORT= PX_CALL_CONV= )
+
+set(_LIBS_DIR ${_PACKAGE_DIR}/NvCloth/lib)
+if(${PAL_PLATFORM_NAME} STREQUAL "Windows")
+    set(${MY_NAME}_LIBRARY
+        ${_LIBS_DIR}/vc141win64-cmake/NvCloth$<$<NOT:$<CONFIG:Release>>:$<UPPER_CASE:$<CONFIG>>>_x64.lib)
+
+    # The NvCloth libs are compiled using /GL, which lld-link does not support.
+    set(${MY_NAME}_LINK_OPTIONS
+        $<$<STREQUAL:${PAL_TRAIT_COMPILER_ID},Clang>:-fuse-ld=link.exe>)
+elseif (${PAL_PLATFORM_NAME} STREQUAL "Linux")
+    set(${MY_NAME}_LIBRARY
+        ${_LIBS_DIR}/linux64-cmake/libNvCloth$<$<NOT:$<CONFIG:Release>>:$<UPPER_CASE:$<CONFIG>>>.a)
+elseif(${PAL_PLATFORM_NAME} STREQUAL "Mac")
+    set(${MY_NAME}_LIBRARY
+        ${_LIBS_DIR}/osx64-cmake/libNvCloth$<$<NOT:$<CONFIG:Release>>:$<UPPER_CASE:$<CONFIG>>>.a)
+elseif(${PAL_PLATFORM_NAME} STREQUAL "iOS")
+    set(${MY_NAME}_LIBRARY
+        ${_LIBS_DIR}/ios-cmake/libNvCloth$<$<NOT:$<CONFIG:Release>>:$<UPPER_CASE:$<CONFIG>>>.a)
+elseif(${PAL_PLATFORM_NAME} STREQUAL "Android")
+    set(${MY_NAME}_LIBRARY
+        ${_LIBS_DIR}/android-arm64-v8a-cmake/libNvCloth$<$<NOT:$<CONFIG:Release>>:$<UPPER_CASE:$<CONFIG>>>.a)
+endif()
+
+add_library(${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(TARGET ${TARGET_WITH_NAMESPACE} INTERFACE ${${MY_NAME}_INCLUDE_DIR})
+target_link_libraries(${TARGET_WITH_NAMESPACE} INTERFACE ${${MY_NAME}_LIBRARY})
+target_compile_definitions(${TARGET_WITH_NAMESPACE} INTERFACE ${${MY_NAME}_COMPILE_DEFINITIONS})
+if(DEFINED ${MY_NAME}_LINK_OPTIONS)
+    target_link_options(${TARGET_WITH_NAMESPACE} INTERFACE ${${MY_NAME}_LINK_OPTIONS})
+endif()
+
+set(${MY_NAME}_FOUND True)

+ 262 - 0
package-system/NvCloth/build_package_image.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+import argparse
+import functools
+import json
+import os
+import re
+import pathlib
+from pathlib import Path
+import shutil
+import subprocess
+from tempfile import TemporaryDirectory
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent / 'Scripts'))
+from builders.vcpkgbuilder import VcpkgBuilder
+import builders.monkeypatch_tempdir_cleanup
+
+class NvClothBuilder(object):
+    def __init__(self, workingDir: pathlib.Path, basePackageSystemDir: pathlib.Path, targetPlatform: str):
+        self._workingDir = workingDir
+        self._packageSystemDir = basePackageSystemDir
+        self._platform = targetPlatform
+        self._env = dict(os.environ)
+        self._env.update(
+            GW_DEPS_ROOT=str(workingDir),
+        )
+
+        self.check_call = functools.partial(subprocess.check_call,
+            cwd=self.workingDir,
+            env=self.env
+        )
+
+    @property
+    def workingDir(self):
+        return self._workingDir
+
+    @property
+    def packageSystemDir(self):
+        return self._packageSystemDir
+
+    @property
+    def platform(self):
+        return self._platform
+
+    @property
+    def env(self):
+        return self._env
+
+    def clone(self, lockToCommit: str):
+        if not (self.workingDir / '.git').exists():
+            self.check_call(
+                ['git', 'init',],
+            )
+            self.check_call(
+                ['git', 'remote', 'add', 'origin', 'https://github.com/NVIDIAGameWorks/NvCloth.git',],
+            )
+
+        self.check_call(
+            ['git', 'fetch', 'origin', '--depth=1', 'pull/58/head:pr-58',],
+        )
+        self.check_call(
+            ['git', 'checkout', 'pr-58',],
+        )
+        
+        # Remove /LTCG and /GL flags as it's causing compile warnings
+        if self.platform == 'windows':
+            windows_cmake_file = self.workingDir / 'NvCloth/compiler/cmake/windows/CMakeLists.txt'
+            f = open(windows_cmake_file, 'r')
+            content = f.read()
+            f.close()
+            content = re.sub('/LTCG', r'', content, flags = re.M)
+            content = re.sub('/GL', r'', content, flags = re.M)
+            f = open(windows_cmake_file, 'w')
+            f.write(content)
+            f.close()
+        
+        # Remove warnings as errors for iOS
+        if self.platform == 'ios':
+            ios_cmake_file = self.workingDir / 'NvCloth/compiler/cmake/ios/CMakeLists.txt'
+            f = open(ios_cmake_file, 'r')
+            content = f.read()
+            f.close()
+            content = re.sub('-Werror', r'', content, flags = re.M)
+            f = open(ios_cmake_file, 'w')
+            f.write(content)
+            f.close()
+
+    def build(self):
+        cmake_scripts_path = os.path.abspath(os.path.join(self.packageSystemDir, '../Scripts/cmake'))
+        nvcloth_dir = self.workingDir / 'NvCloth'
+        
+        ly_3rdparty_path = os.getenv('LY_3RDPARTY_PATH')
+
+        folder_names = { 
+            #system-name  cmake generation, cmake build
+            'mac'       : ([
+                '-G', 'Xcode',
+                '-DTARGET_BUILD_PLATFORM=mac',
+                '-DNV_CLOTH_ENABLE_CUDA=0', '-DUSE_CUDA=0',
+                '-DPX_GENERATE_GPU_PROJECTS=0',
+                '-DPX_STATIC_LIBRARIES=1',
+                f'-DPX_OUTPUT_DLL_DIR={nvcloth_dir}/bin/osx64-cmake',
+                f'-DPX_OUTPUT_LIB_DIR={nvcloth_dir}/lib/osx64-cmake',
+                f'-DPX_OUTPUT_EXE_DIR={nvcloth_dir}/bin/osx64-cmake'
+            ], []),
+            'ios'       : ([
+                '-G', 'Xcode',
+                f'-DCMAKE_TOOLCHAIN_FILE={cmake_scripts_path}/Platform/iOS/Toolchain_ios.cmake',
+                '-DPACKAGE_PLATFORM=ios',
+                '-DTARGET_BUILD_PLATFORM=ios',
+                '-DCMAKE_XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET="10.0"',
+                '-DNV_CLOTH_ENABLE_CUDA=0', '-DUSE_CUDA=0',
+                '-DPX_GENERATE_GPU_PROJECTS=0',
+                '-DPX_STATIC_LIBRARIES=1',
+                f'-DPX_OUTPUT_DLL_DIR={nvcloth_dir}/bin/ios-cmake',
+                f'-DPX_OUTPUT_LIB_DIR={nvcloth_dir}/lib/ios-cmake',
+                f'-DPX_OUTPUT_EXE_DIR={nvcloth_dir}/bin/ios-cmake'
+            ], [
+                '--',
+                '-destination generic/platform=iOS'
+            ]),
+            'linux'     : ([
+                '-G', 'Ninja Multi-Config',
+                '-DCMAKE_C_COMPILER=clang-6.0', 
+                '-DCMAKE_CXX_COMPILER=clang++-6.0',
+                '-DTARGET_BUILD_PLATFORM=linux',
+                '-DNV_CLOTH_ENABLE_CUDA=0',
+                '-DPX_GENERATE_GPU_PROJECTS=0',
+                '-DPX_STATIC_LIBRARIES=1',
+                f'-DPX_OUTPUT_DLL_DIR={nvcloth_dir}/bin/linux64-cmake',
+                f'-DPX_OUTPUT_LIB_DIR={nvcloth_dir}/lib/linux64-cmake',
+                f'-DPX_OUTPUT_EXE_DIR={nvcloth_dir}/bin/linux64-cmake'
+            ], []),
+            'windows'   : ([
+                '-G', 'Visual Studio 15 2017',
+                '-Ax64',
+                '-DTARGET_BUILD_PLATFORM=windows',
+                '-DNV_CLOTH_ENABLE_DX11=0',
+                '-DNV_CLOTH_ENABLE_CUDA=0',
+                '-DPX_GENERATE_GPU_PROJECTS=0',
+                '-DSTATIC_WINCRT=0',
+                '-DPX_STATIC_LIBRARIES=1',
+                f'-DPX_OUTPUT_DLL_DIR={nvcloth_dir}/bin/vc141win64-cmake',
+                f'-DPX_OUTPUT_LIB_DIR={nvcloth_dir}/lib/vc141win64-cmake',
+                f'-DPX_OUTPUT_EXE_DIR={nvcloth_dir}/bin/vc141win64-cmake'
+            ], []),
+            'android'   : ([
+                '-G', 'Ninja Multi-Config',
+                f'-DCMAKE_TOOLCHAIN_FILE={cmake_scripts_path}/Platform/Android/Toolchain_android.cmake',
+                '-DANDROID_ABI=arm64-v8a',
+                '-DANDROID_ARM_MODE=arm',
+                '-DANDROID_ARM_NEON=TRUE',
+                '-DANDROID_NATIVE_API_LEVEL=21',
+                f'-DLY_NDK_DIR={ly_3rdparty_path}/android-ndk/r21d',
+                '-DPACKAGE_PLATFORM=android',
+                '-DPX_STATIC_LIBRARIES=1',
+                f'-DPX_OUTPUT_DLL_DIR={nvcloth_dir}/bin/android-arm64-v8a-cmake',
+                f'-DPX_OUTPUT_LIB_DIR={nvcloth_dir}/lib/android-arm64-v8a-cmake',
+                f'-DPX_OUTPUT_EXE_DIR={nvcloth_dir}/bin/android-arm64-v8a-cmake'
+            ], []) # Android needs to have ninja in the path
+        }
+        
+        # intentionally generate a keyerror if its not a good platform:
+        cmake_generation, cmake_build = folder_names[self.platform]
+        
+        build_dir = os.path.join(nvcloth_dir, 'build', self.platform)
+        os.makedirs(build_dir, exist_ok=True)
+        
+        # Generate
+        cmake_generate_call =['cmake', f'{nvcloth_dir}/compiler/cmake/{self.platform}', f'-B{build_dir}']
+        if cmake_generation:
+            cmake_generate_call += cmake_generation
+        print(cmake_generate_call)
+        self.check_call(cmake_generate_call)
+
+        # Build
+        for config in ('debug', 'profile', 'release'):
+            cmake_build_call =['cmake', '--build', build_dir, '--config', config]
+            if cmake_build:
+                cmake_build_call += cmake_build
+            print(cmake_build_call)
+            self.check_call(cmake_build_call)
+
+    def copyBuildOutputTo(self, packageDir: pathlib.Path):
+        if packageDir.exists():
+            shutil.rmtree(packageDir)
+    
+        for dirname in ('NvCloth/lib', 'NvCloth/include', 'NvCloth/extensions/include', 'PxShared/include'):
+            shutil.copytree(
+                src=self.workingDir / dirname,
+                dst=packageDir / dirname,
+                symlinks=True,
+            )
+        shutil.copy2(
+            src=self.workingDir / 'README.md',
+            dst=packageDir / 'README.md',
+        )
+        shutil.copy2(
+            src=self.workingDir / 'NvCloth/license.txt',
+            dst=packageDir / 'NvCloth/license.txt',
+        )
+        shutil.copy2(
+            src=self.workingDir / 'PxShared/license.txt',
+            dst=packageDir / 'PxShared/license.txt',
+        )
+
+    def writePackageInfoFile(self, packageDir: pathlib.Path, settings: dict):
+        with (packageDir / 'PackageInfo.json').open('w') as fh:
+            json.dump(settings, fh, indent=4)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--platform-name',
+        dest='platformName',
+        choices=['windows', 'linux', 'android', 'mac', 'ios'],
+        default=VcpkgBuilder.defaultPackagePlatformName(),
+    )
+    args = parser.parse_args()
+
+    packageSystemDir = Path(__file__).resolve().parents[1]
+    packageSourceDir = packageSystemDir / 'NvCloth'
+    packageRoot = packageSystemDir / f'NvCloth-{args.platformName}'
+
+    cmakeFindFile = packageSourceDir / f'FindNvCloth_{args.platformName}.cmake'
+    if not cmakeFindFile.exists():
+        cmakeFindFile = packageSourceDir / 'FindNvCloth.cmake'
+
+    with TemporaryDirectory() as tempdir:
+        tempdir = Path(tempdir)
+        builder = NvClothBuilder(workingDir=tempdir, basePackageSystemDir=packageSystemDir, targetPlatform=args.platformName)
+        builder.clone('8e100cca5888d09f40f4721cc433f284b1841e65')
+        builder.build()
+        builder.copyBuildOutputTo(packageRoot/'NvCloth')
+        
+        # Version v1.1.6-4-gd243404-pr58 describes commit 8e100cc,
+        # which is 4 commits above 1.1.6 release (commit d243404),
+        # plus pull request 58 applied on top.
+        builder.writePackageInfoFile(
+            packageRoot,
+            settings={
+                'PackageName': f'NvCloth-v1.1.6-4-gd243404-pr58-rev1-{args.platformName}',
+                'URL': 'https://github.com/NVIDIAGameWorks/NvCloth.git',
+                'License': 'custom',
+                'LicenseFile': 'NvCloth/NvCloth/license.txt',
+            },
+        )
+        
+        shutil.copy2(
+            src=cmakeFindFile,
+            dst=packageRoot / 'FindNvCloth.cmake'
+        )
+
+if __name__ == '__main__':
+    main()

+ 308 - 0
package-system/PhysX/Build-physx-profile-config.patch

@@ -0,0 +1,308 @@
+From c635f3a3122141d3641109275486e45b2a2df021 Mon Sep 17 00:00:00 2001
+Date: Fri, 11 Jun 2021 11:06:15 -0700
+Subject: [PATCH] Build physx profile config
+
+---
+ ...d-ios-shared-libraries-as-frameworks.patch | 55 ++++++++++++++++
+ ports/physx/fix-compiler-flag.patch           |  2 +-
+ ports/physx/portfile.cmake                    | 64 +++++++++++++++----
+ ports/vcpkg-cmake/vcpkg_cmake_build.cmake     |  7 +-
+ ports/vcpkg-cmake/vcpkg_cmake_configure.cmake | 18 +++++-
+ 5 files changed, 132 insertions(+), 14 deletions(-)
+ create mode 100644 ports/physx/build-ios-shared-libraries-as-frameworks.patch
+
+diff --git a/ports/physx/build-ios-shared-libraries-as-frameworks.patch b/ports/physx/build-ios-shared-libraries-as-frameworks.patch
+new file mode 100644
+index 00000000..e0dd5ac2
+--- /dev/null
++++ b/ports/physx/build-ios-shared-libraries-as-frameworks.patch
+@@ -0,0 +1,55 @@
++From 3ae88b0cfe11d77430881d674aa14a2e711788e8 Mon Sep 17 00:00:00 2001
++From: ---
++Date: Thu, 10 Jun 2021 16:28:38 -0700
++Subject: [PATCH] Build iOS shared libraries as frameworks
++
++---
++ physx/buildtools/presets/public/ios64.xml     |  3 +-
++ .../source/compiler/cmake/ios/CMakeLists.txt  | 35 +++++++++++++++++--
++ 2 files changed, 35 insertions(+), 3 deletions(-)
++
++diff --git a/physx/source/compiler/cmake/ios/CMakeLists.txt b/physx/source/compiler/cmake/ios/CMakeLists.txt
++index 5605e9af..1ff37a62 100644
++--- a/physx/source/compiler/cmake/ios/CMakeLists.txt
+++++ b/physx/source/compiler/cmake/ios/CMakeLists.txt
++@@ -89,4 +89,35 @@ SET_PROPERTY(TARGET SimulationController PROPERTY FOLDER "PhysX SDK")
++ SET_PROPERTY(TARGET FastXml PROPERTY FOLDER "PhysX SDK")
++ SET_PROPERTY(TARGET PhysXPvdSDK PROPERTY FOLDER "PhysX SDK")
++ SET_PROPERTY(TARGET PhysXTask PROPERTY FOLDER "PhysX SDK")
++-SET_PROPERTY(TARGET PhysXFoundation PROPERTY FOLDER "PhysX SDK")
++\ No newline at end of file
+++SET_PROPERTY(TARGET PhysXFoundation PROPERTY FOLDER "PhysX SDK")
+++
+++IF(PHYSXCOMMON_LIBTYPE STREQUAL "SHARED")
+++    SET(PHYSX_IOS_IDENTIFIER "com.nvidia.lib.physx")
+++    SET(PHYSX_COMMON_IOS_IDENTIFIER "com.nvidia.lib.physxcommon")
+++    SET(PHYSX_COOKING_IOS_IDENTIFIER "com.nvidia.lib.physxcooking")
+++    SET(PHYSX_FOUNDATION_IOS_IDENTIFIER "com.nvidia.lib.physxfoundation")
+++
+++    SET_TARGET_PROPERTIES(PhysX PROPERTIES
+++        FRAMEWORK TRUE
+++        MACOSX_FRAMEWORK_IDENTIFIER ${PHYSX_IOS_IDENTIFIER}
+++        XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${PHYSX_IOS_IDENTIFIER}
+++    )
+++
+++    SET_TARGET_PROPERTIES(PhysXCommon PROPERTIES
+++        FRAMEWORK TRUE
+++        MACOSX_FRAMEWORK_IDENTIFIER ${PHYSX_COMMON_IOS_IDENTIFIER}
+++        XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${PHYSX_COMMON_IOS_IDENTIFIER}
+++    )
+++
+++    SET_TARGET_PROPERTIES(PhysXCooking PROPERTIES
+++        FRAMEWORK TRUE
+++        MACOSX_FRAMEWORK_IDENTIFIER ${PHYSX_COOKING_IOS_IDENTIFIER}
+++        XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${PHYSX_COOKING_IOS_IDENTIFIER}
+++    )
+++
+++    SET_TARGET_PROPERTIES(PhysXFoundation PROPERTIES
+++        FRAMEWORK TRUE
+++        MACOSX_FRAMEWORK_IDENTIFIER ${PHYSX_FOUNDATION_IOS_IDENTIFIER}
+++        XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER ${PHYSX_FOUNDATION_IOS_IDENTIFIER}
+++    )
+++ENDIF()
++-- 
++2.30.1
++
+diff --git a/ports/physx/fix-compiler-flag.patch b/ports/physx/fix-compiler-flag.patch
+index cfb253e7..06aeb0c8 100644
+--- a/ports/physx/fix-compiler-flag.patch
++++ b/ports/physx/fix-compiler-flag.patch
+@@ -47,12 +47,12 @@ index a1ab3596..dbd20fb0 100644
+  
+ +if(FALSE)
+  SET(PHYSX_CXX_FLAGS_DEBUG "/Od ${WINCRT_DEBUG} /RTCu /Zi" CACHE INTERNAL "PhysX Debug CXX Flags")
+++endif()
+  # PT: changed /Ox to /O2 because "the /Ox compiler option enables only a subset of the speed optimization options enabled by /O2."
+  # See https://docs.microsoft.com/en-us/cpp/build/reference/ox-full-optimization?view=vs-2019
+  SET(PHYSX_CXX_FLAGS_CHECKED "/O2 ${WINCRT_NDEBUG} /Zi" CACHE INTERNAL "PhysX Checked CXX Flags")
+  SET(PHYSX_CXX_FLAGS_PROFILE "/O2 ${WINCRT_NDEBUG} /Zi" CACHE INTERNAL "PhysX Profile CXX Flags")
+  SET(PHYSX_CXX_FLAGS_RELEASE "/O2 ${WINCRT_NDEBUG} /Zi" CACHE INTERNAL "PhysX Release CXX Flags")
+-+endif()
+  
+  # cache lib type defs
+  IF(PX_GENERATE_STATIC_LIBRARIES)	
+diff --git a/ports/physx/portfile.cmake b/ports/physx/portfile.cmake
+index 3b905cc0..42bd05c2 100644
+--- a/ports/physx/portfile.cmake
++++ b/ports/physx/portfile.cmake
+@@ -3,12 +3,13 @@ vcpkg_fail_port_install(ON_TARGET MINGW)
+ vcpkg_from_github(
+     OUT_SOURCE_PATH SOURCE_PATH
+     REPO NVIDIAGameWorks/PhysX
+-    REF 93c6dd21b545605185f2febc8eeacebe49a99479
+-    SHA512 c9f50255ca9e0f1ebdb9926992315a62b77e2eea3addd4e65217283490714e71e24f2f687717dd8eb155078a1a6b25c9fadc123ce8bc4c5615f7ac66cd6b11aa
++    REF c3d5537bdebd6f5cd82fcaf87474b838fe6fd5fa
++    SHA512 6939c9703a01dab8f2463bf3dfd303be5a2869f35e56c3f6102473d5bedf6cfaf167596dfd98cf09c26cc123476f559f9357f0adcc33e9980f9b4f4cdd77768a
+     HEAD_REF master
+     PATCHES
+         fix-compiler-flag.patch
+         remove-werror.patch
++        build-ios-shared-libraries-as-frameworks.patch
+ )
+ 
+ if(NOT DEFINED RELEASE_CONFIGURATION)
+@@ -31,12 +32,17 @@ set(OPTIONS
+ )
+ 
+ set(OPTIONS_RELEASE
+-    "-DPX_OUTPUT_BIN_DIR=${CURRENT_PACKAGES_DIR}"
+-    "-DPX_OUTPUT_LIB_DIR=${CURRENT_PACKAGES_DIR}"
++    "-DPX_OUTPUT_BIN_DIR=${CURRENT_PACKAGES_DIR}/build_output"
++    "-DPX_OUTPUT_LIB_DIR=${CURRENT_PACKAGES_DIR}/build_output"
++)
++set(OPTIONS_PROFILE
++    "-DPX_OUTPUT_BIN_DIR=${CURRENT_PACKAGES_DIR}/build_output/profile"
++    "-DPX_OUTPUT_LIB_DIR=${CURRENT_PACKAGES_DIR}/build_output/profile"
++    "-DNV_USE_DEBUG_WINCRT=ON"
+ )
+ set(OPTIONS_DEBUG
+-    "-DPX_OUTPUT_BIN_DIR=${CURRENT_PACKAGES_DIR}/debug"
+-    "-DPX_OUTPUT_LIB_DIR=${CURRENT_PACKAGES_DIR}/debug"
++    "-DPX_OUTPUT_BIN_DIR=${CURRENT_PACKAGES_DIR}/build_output/debug"
++    "-DPX_OUTPUT_LIB_DIR=${CURRENT_PACKAGES_DIR}/build_output/debug"
+     "-DNV_USE_DEBUG_WINCRT=ON"
+ )
+ 
+@@ -50,6 +56,11 @@ elseif(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_FREEBSD)
+     list(APPEND OPTIONS "-DTARGET_BUILD_PLATFORM=linux")
+ elseif(VCPKG_TARGET_IS_ANDROID)
+     list(APPEND OPTIONS "-DTARGET_BUILD_PLATFORM=android")
++elseif(VCPKG_TARGET_IS_IOS)
++    list(APPEND OPTIONS "-DTARGET_BUILD_PLATFORM=ios"
++        "-DIOS_DEPLOYMENT_TARGET=10.0"
++        "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.0"
++    )
+ else()
+     message(FATAL_ERROR "Unhandled or unsupported target platform.")
+ endif()
+@@ -82,6 +92,7 @@ vcpkg_cmake_configure(
+     OPTIONS ${OPTIONS}
+     OPTIONS_DEBUG ${OPTIONS_DEBUG}
+     OPTIONS_RELEASE ${OPTIONS_RELEASE}
++    OPTIONS_PROFILE ${OPTIONS_PROFILE}
+ )
+ vcpkg_cmake_install()
+ 
+@@ -91,12 +103,25 @@ vcpkg_cmake_install()
+ function(fixup_physx_artifacts)
+     macro(_fixup _IN_DIRECTORY _OUT_DIRECTORY)
+         foreach(_SUFFIX IN LISTS _fpa_SUFFIXES)
++            if(_SUFFIX STREQUAL ".framework")
++                set(list_directories TRUE)
++            else()
++                set(list_directories FALSE)
++            endif()
+             file(GLOB_RECURSE _ARTIFACTS
+-                LIST_DIRECTORIES false
+-                "${CURRENT_PACKAGES_DIR}/${_IN_DIRECTORY}/*${_SUFFIX}"
++                LIST_DIRECTORIES "${list_directories}"
++                "${CURRENT_PACKAGES_DIR}/build_output/${_IN_DIRECTORY}/*${_SUFFIX}"
+             )
+-            if(_ARTIFACTS)
++            if(_ARTIFACTS AND NOT _SUFFIX STREQUAL ".framework")
++                # copy all files at once
+                 file(COPY ${_ARTIFACTS} DESTINATION "${CURRENT_PACKAGES_DIR}/${_OUT_DIRECTORY}")
++            else()
++                foreach(_ARTIFACT IN LISTS _ARTIFACTS)
++                    # copy each .framework directory individually
++                    if(_ARTIFACT MATCHES "\.framework$")
++                        file(COPY ${_ARTIFACT} DESTINATION "${CURRENT_PACKAGES_DIR}/${_OUT_DIRECTORY}")
++                    endif()
++                endforeach()
+             endif()
+         endforeach()
+     endmacro()
+@@ -104,6 +129,7 @@ function(fixup_physx_artifacts)
+     cmake_parse_arguments(_fpa "" "DIRECTORY" "SUFFIXES" ${ARGN})
+     _fixup("bin" ${_fpa_DIRECTORY})
+     _fixup("debug/bin" "debug/${_fpa_DIRECTORY}")
++    _fixup("profile/bin" "profile/${_fpa_DIRECTORY}")
+ endfunction()
+ 
+ fixup_physx_artifacts(
+@@ -112,22 +138,25 @@ fixup_physx_artifacts(
+ )
+ fixup_physx_artifacts(
+     DIRECTORY "bin"
+-    SUFFIXES ${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX} ".pdb"
++    SUFFIXES ${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX} ".pdb" ".framework"
+ )
+ 
+ # Remove compiler directory and descendents.
++file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/build_output/")
+ if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+     file(REMOVE_RECURSE
+         "${CURRENT_PACKAGES_DIR}/bin/"
+         "${CURRENT_PACKAGES_DIR}/debug/bin/"
++        "${CURRENT_PACKAGES_DIR}/profile/bin/"
+     )
+ else()
+     file(GLOB PHYSX_ARTIFACTS LIST_DIRECTORIES true
+         "${CURRENT_PACKAGES_DIR}/bin/*"
+         "${CURRENT_PACKAGES_DIR}/debug/bin/*"
++        "${CURRENT_PACKAGES_DIR}/profile/bin/*"
+     )
+     foreach(_ARTIFACT IN LISTS PHYSX_ARTIFACTS)
+-        if(IS_DIRECTORY ${_ARTIFACT})
++        if(IS_DIRECTORY ${_ARTIFACT} AND NOT _ARTIFACT MATCHES "\.framework$")
+             file(REMOVE_RECURSE ${_ARTIFACT})
+         endif()
+     endforeach()
+@@ -136,6 +165,20 @@ endif()
+ file(REMOVE_RECURSE
+     "${CURRENT_PACKAGES_DIR}/debug/include"
+     "${CURRENT_PACKAGES_DIR}/debug/source"
++    "${CURRENT_PACKAGES_DIR}/profile/include"
++    "${CURRENT_PACKAGES_DIR}/profile/source"
+     "${CURRENT_PACKAGES_DIR}/source"
+ )
+ file(INSTALL ${SOURCE_PATH}/README.md DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
++if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_LIBRARY_LINKAGE STREQUAL "static")
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc142.mt/debug/PhysXDevice64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc142.mt/profile/PhysXDevice64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/profile/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc142.mt/release/PhysXDevice64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc140.mt/debug/PhysXGpu_64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc140.mt/profile/PhysXGpu_64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/profile/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/win.x86_64.vc140.mt/release/PhysXGpu_64.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin)
++elseif(VCPKG_TARGET_IS_LINUX AND NOT VCPKG_LIBRARY_LINKAGE STREQUAL "static")
++    file(INSTALL ${SOURCE_PATH}/physx/bin/linux.clang/debug/libPhysXGpu_64.so DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/linux.clang/profile/libPhysXGpu_64.so DESTINATION ${CURRENT_PACKAGES_DIR}/profile/bin)
++    file(INSTALL ${SOURCE_PATH}/physx/bin/linux.clang/release/libPhysXGpu_64.so DESTINATION ${CURRENT_PACKAGES_DIR}/bin)
++endif()
+diff --git a/ports/vcpkg-cmake/vcpkg_cmake_build.cmake b/ports/vcpkg-cmake/vcpkg_cmake_build.cmake
+index ef27a6c9..533343aa 100644
+--- a/ports/vcpkg-cmake/vcpkg_cmake_build.cmake
++++ b/ports/vcpkg-cmake/vcpkg_cmake_build.cmake
+@@ -71,11 +71,14 @@ function(vcpkg_cmake_build)
+         set(target_args "--target" "${arg_TARGET}")
+     endif()
+ 
+-    foreach(buildtype IN ITEMS debug release)
++    foreach(buildtype IN ITEMS debug profile release)
+         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL buildtype)
+             if(buildtype STREQUAL "debug")
+                 set(short_buildtype "dbg")
+                 set(cmake_config "Debug")
++            elseif(buildtype STREQUAL "profile")
++                set(short_buildtype "profile")
++                set(cmake_config "Profile")
+             else()
+                 set(short_buildtype "rel")
+                 set(cmake_config "Release")
+@@ -87,6 +90,8 @@ function(vcpkg_cmake_build)
+                 set(env_path_backup "$ENV{PATH}")
+                 if(buildtype STREQUAL "debug")
+                     vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
++                elseif(buildtype STREQUAL "profile")
++                    vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/profile/bin")
+                 else()
+                     vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
+                 endif()
+diff --git a/ports/vcpkg-cmake/vcpkg_cmake_configure.cmake b/ports/vcpkg-cmake/vcpkg_cmake_configure.cmake
+index 3b7d31ef..8ce2e5da 100644
+--- a/ports/vcpkg-cmake/vcpkg_cmake_configure.cmake
++++ b/ports/vcpkg-cmake/vcpkg_cmake_configure.cmake
+@@ -88,7 +88,7 @@ function(vcpkg_cmake_configure)
+     cmake_parse_arguments(PARSE_ARGV 0 "arg"
+         "PREFER_NINJA;DISABLE_PARALLEL_CONFIGURE;WINDOWS_USE_MSBUILD;NO_CHARSET_FLAG"
+         "SOURCE_PATH;GENERATOR;LOGFILE_BASE"
+-        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE"
++        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;OPTIONS_PROFILE"
+     )
+ 
+     if(DEFINED CACHE{Z_VCPKG_CMAKE_GENERATOR})
+@@ -385,6 +385,22 @@ function(vcpkg_cmake_configure)
+                 LOGNAME "${arg_LOGFILE_BASE}-rel"
+             )
+         endif()
++
++        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "profile")
++            message(STATUS "Configuring ${TARGET_TRIPLET}-profile")
++            file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-profile")
++            vcpkg_execute_required_process(
++                COMMAND
++                    "${CMAKE_COMMAND}" "${arg_SOURCE_PATH}"
++                    ${arg_OPTIONS}
++                    ${arg_OPTIONS_PROFILE}
++                    -G "${generator}"
++                    "-DCMAKE_BUILD_TYPE=Profile"
++                    "-DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}"
++                WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-profile"
++                LOGNAME "${arg_LOGFILE_BASE}-profile"
++            )
++        endif()
+     endif()
+ 
+     set(Z_VCPKG_CMAKE_GENERATOR "${generator}" CACHE INTERNAL "The generator which was used to configure CMake.")
+-- 
+2.30.1
+

+ 84 - 0
package-system/PhysX/FindPhysX.cmake.template

@@ -0,0 +1,84 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "PhysX")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(_PACKAGE_DIR $${CMAKE_CURRENT_LIST_DIR}/PhysX/$$<IF:$$<BOOL:$${LY_MONOLITHIC_GAME}>,physx,pxshared>/)
+
+set($${MY_NAME}_INCLUDE_DIR
+    $${_PACKAGE_DIR}/include
+    $${_PACKAGE_DIR}/include/foundation
+    $${_PACKAGE_DIR}/include/geometry
+)
+
+set($${MY_NAME}_COMPILE_DEFINITIONS $$<$$<BOOL:$${LY_MONOLITHIC_GAME}>:PX_PHYSX_STATIC_LIB>)
+
+set(PATH_TO_STATIC_LIBS $${_PACKAGE_DIR}/$$<IF:$$<CONFIG:debug>,debug/,$$<$$<CONFIG:profile>:profile/>>lib)
+set(PATH_TO_SHARED_LIBS $${_PACKAGE_DIR}/$$<IF:$$<CONFIG:debug>,debug/,$$<$$<CONFIG:profile>:profile/>>bin)
+if(DEFINED CMAKE_IMPORT_LIBRARY_SUFFIX)
+    set(PATH_TO_IMPORT_LIBS $${PATH_TO_STATIC_LIBS})
+    set(import_lib_prefix $${CMAKE_IMPORT_LIBRARY_PREFIX})
+    set(import_lib_suffix $${CMAKE_IMPORT_LIBRARY_SUFFIX})
+else()
+    set(PATH_TO_IMPORT_LIBS $${PATH_TO_SHARED_LIBS})
+    set(import_lib_prefix $${CMAKE_SHARED_LIBRARY_PREFIX})
+    set(import_lib_suffix $${CMAKE_SHARED_LIBRARY_SUFFIX})
+endif()
+
+set($${MY_NAME}_LIBRARIES
+    $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXCharacterKinematic_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+    $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXVehicle_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+    $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXExtensions_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+    $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXPvdSDK_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+)
+
+set(extra_static_libs ${EXTRA_STATIC_LIBS_NON_MONOLITHIC})
+set(extra_shared_libs ${EXTRA_SHARED_LIBS})
+
+if(LY_MONOLITHIC_GAME)
+    list(APPEND $${MY_NAME}_LIBRARIES
+        $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysX_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+        $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXCooking_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+        $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXFoundation_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+        $${PATH_TO_STATIC_LIBS}/$${CMAKE_STATIC_LIBRARY_PREFIX}PhysXCommon_static_64$${CMAKE_STATIC_LIBRARY_SUFFIX}
+    )
+    if(extra_shared_libs)
+        set($${MY_NAME}_RUNTIME_DEPENDENCIES
+            $${extra_shared_libs}
+        )
+    endif()
+else()
+    list(APPEND $${MY_NAME}_LIBRARIES
+        $${PATH_TO_IMPORT_LIBS}/$${import_lib_prefix}PhysX_64$${import_lib_suffix}
+        $${PATH_TO_IMPORT_LIBS}/$${import_lib_prefix}PhysXCooking_64$${import_lib_suffix}
+        $${PATH_TO_IMPORT_LIBS}/$${import_lib_prefix}PhysXFoundation_64$${import_lib_suffix}
+        $${PATH_TO_IMPORT_LIBS}/$${import_lib_prefix}PhysXCommon_64$${import_lib_suffix}
+        $${extra_static_libs}
+    )
+    set($${MY_NAME}_RUNTIME_DEPENDENCIES
+        $${PATH_TO_SHARED_LIBS}/$${CMAKE_SHARED_LIBRARY_PREFIX}PhysX_64$${CMAKE_SHARED_LIBRARY_SUFFIX}
+        $${PATH_TO_SHARED_LIBS}/$${CMAKE_SHARED_LIBRARY_PREFIX}PhysXCooking_64$${CMAKE_SHARED_LIBRARY_SUFFIX}
+        $${PATH_TO_SHARED_LIBS}/$${CMAKE_SHARED_LIBRARY_PREFIX}PhysXFoundation_64$${CMAKE_SHARED_LIBRARY_SUFFIX}
+        $${PATH_TO_SHARED_LIBS}/$${CMAKE_SHARED_LIBRARY_PREFIX}PhysXCommon_64$${CMAKE_SHARED_LIBRARY_SUFFIX}
+        $${extra_shared_libs}
+    )
+endif()
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_INCLUDE_DIR})
+target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_LIBRARIES})
+target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_COMPILE_DEFINITIONS})
+if(DEFINED $${MY_NAME}_RUNTIME_DEPENDENCIES)
+    ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+endif()
+
+set($${MY_NAME}_FOUND True)

+ 65 - 0
package-system/PhysX/FindPhysX_ios.cmake.template

@@ -0,0 +1,65 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "PhysX")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(_PACKAGE_DIR $${CMAKE_CURRENT_LIST_DIR}/PhysX/$$<IF:$$<BOOL:$${LY_MONOLITHIC_GAME}>,physx,pxshared>/)
+
+set($${MY_NAME}_INCLUDE_DIR
+    $${_PACKAGE_DIR}/include
+    $${_PACKAGE_DIR}/include/foundation
+    $${_PACKAGE_DIR}/include/geometry
+)
+
+set($${MY_NAME}_COMPILE_DEFINITIONS $$<$$<BOOL:$${LY_MONOLITHIC_GAME}>:PX_PHYSX_STATIC_LIB>)
+
+set(PATH_TO_STATIC_LIBS $${_PACKAGE_DIR}/$$<IF:$$<CONFIG:debug>,debug,$$<$$<CONFIG:profile>:profile>>/lib)
+# Frameworks are added and managed by XCode during the build process.
+# At the moment $$<CONFIG> does not get replaced for "debug", "profile" or
+# "release" for frameworks when added to XCode, so it's not able to find
+# the frameworks since their path is wrong. To workaround this, for now it
+# will only use the release version of the library.
+set(PATH_TO_SHARED_LIBS $${_PACKAGE_DIR}/bin)
+
+
+set($${MY_NAME}_LIBRARIES
+    $${PATH_TO_STATIC_LIBS}/libPhysXCharacterKinematic_static_64.a
+    $${PATH_TO_STATIC_LIBS}/libPhysXVehicle_static_64.a
+    $${PATH_TO_STATIC_LIBS}/libPhysXExtensions_static_64.a
+    $${PATH_TO_STATIC_LIBS}/libPhysXPvdSDK_static_64.a
+)
+if(LY_MONOLITHIC_GAME)
+    list(APPEND $${MY_NAME}_LIBRARIES
+        $${PATH_TO_STATIC_LIBS}/libPhysX_static_64.a
+        $${PATH_TO_STATIC_LIBS}/libPhysXCooking_static_64.a
+        $${PATH_TO_STATIC_LIBS}/libPhysXFoundation_static_64.a
+        $${PATH_TO_STATIC_LIBS}/libPhysXCommon_static_64.a
+    )
+else()
+    list(APPEND $${MY_NAME}_LIBRARIES
+        $${PATH_TO_SHARED_LIBS}/PhysX.framework
+        $${PATH_TO_SHARED_LIBS}/PhysXCooking.framework
+        $${PATH_TO_SHARED_LIBS}/PhysXFoundation.framework
+        $${PATH_TO_SHARED_LIBS}/PhysXCommon.framework
+    )
+endif()
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_INCLUDE_DIR})
+target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_LIBRARIES})
+target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_COMPILE_DEFINITIONS})
+
+# Frameworks do not need to get added as runtime dependencies
+# since they are handled by XCode directly. Frameworks will
+# be copied into the app when constructed by XCode.
+
+set($${MY_NAME}_FOUND True)

+ 126 - 0
package-system/PhysX/build_package_image.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import argparse
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent / 'Scripts'))
+from builders.vcpkgbuilder import VcpkgBuilder
+import builders.monkeypatch_tempdir_cleanup
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--platform-name',
+        dest='platformName',
+        choices=['windows', 'android', 'mac', 'ios', 'linux'],
+        default=VcpkgBuilder.defaultPackagePlatformName(),
+    )
+    args = parser.parse_args()
+
+    packageSystemDir = Path(__file__).resolve().parents[1]
+    physxPackageSourceDir = packageSystemDir / 'PhysX'
+    outputDir = packageSystemDir / f'PhysX-{args.platformName}'
+
+    cmakeFindFile = physxPackageSourceDir / f'FindPhysX_{args.platformName}.cmake.template'
+    if not cmakeFindFile.exists():
+        cmakeFindFile = physxPackageSourceDir / 'FindPhysX.cmake.template'
+    cmakeFindFileTemplate = cmakeFindFile.open().read()
+
+    buildPhysXInProfileConfigPatch = (physxPackageSourceDir / 'Build-physx-profile-config.patch')
+
+    extraLibsPerPlatform = {
+        'linux': {
+            'EXTRA_SHARED_LIBS': '${CMAKE_CURRENT_LIST_DIR}/PhysX/pxshared/$<IF:$<CONFIG:debug>,debug/,$<$<CONFIG:profile>:profile/>>bin/libPhysXGpu_64.so',
+            'EXTRA_STATIC_LIBS_NON_MONOLITHIC': '',
+        },
+        'windows': {
+            'EXTRA_SHARED_LIBS': '\n'.join((
+                '${CMAKE_CURRENT_LIST_DIR}/PhysX/pxshared/$<IF:$<CONFIG:debug>,debug/,$<$<CONFIG:profile>:profile/>>bin/PhysXDevice64.dll'
+                '${CMAKE_CURRENT_LIST_DIR}/PhysX/pxshared/$<IF:$<CONFIG:debug>,debug/,$<$<CONFIG:profile>:profile/>>bin/PhysGpu_64.dll'
+            )),
+            'EXTRA_STATIC_LIBS_NON_MONOLITHIC': '\n'.join((
+                '${PATH_TO_STATIC_LIBS}/LowLevel_static_64.lib',
+                '${PATH_TO_STATIC_LIBS}/LowLevelAABB_static_64.lib',
+                '${PATH_TO_STATIC_LIBS}/LowLevelDynamics_static_64.lib',
+                '${PATH_TO_STATIC_LIBS}/PhysXTask_static_64.lib',
+                '${PATH_TO_STATIC_LIBS}/SceneQuery_static_64.lib',
+                '${PATH_TO_STATIC_LIBS}/SimulationController_static_64.lib',
+            )),
+        },
+        'mac': {
+            'EXTRA_SHARED_LIBS': '',
+            'EXTRA_STATIC_LIBS_NON_MONOLITHIC': '',
+        },
+        'ios': {
+            'EXTRA_SHARED_LIBS': '',
+            'EXTRA_STATIC_LIBS_NON_MONOLITHIC': '',
+        },
+        'android': {
+            'EXTRA_SHARED_LIBS': '',
+            'EXTRA_STATIC_LIBS_NON_MONOLITHIC': '',
+        },
+    }
+    with TemporaryDirectory() as tempdir:
+        tempdir = Path(tempdir)
+
+        firstTime = True
+
+        # We package PhysX static and dynamic libraries for all supported platforms
+        for maybeStatic in (True, False):
+            builder = VcpkgBuilder(
+                packageName='PhysX',
+                portName='physx',
+                vcpkgDir=tempdir,
+                targetPlatform=args.platformName,
+                static=maybeStatic
+            )
+            if firstTime:
+                builder.cloneVcpkg('751fc199af8d33eb300af5edbd9e3b77c48f0bca')
+                builder.patch(buildPhysXInProfileConfigPatch)
+                builder.bootstrap()
+            builder.build()
+
+            if maybeStatic:
+                subdir = 'physx'
+            else:
+                subdir = 'pxshared'
+            builder.copyBuildOutputTo(
+                outputDir,
+                extraFiles={
+                    next(builder.vcpkgDir.glob(f'buildtrees/physx/src/*/LICENSE.md')): outputDir / builder.packageName / 'LICENSE.md',
+                    next(builder.vcpkgDir.glob(f'buildtrees/physx/src/*/README.md')): outputDir / builder.packageName / 'README.md',
+                },
+                subdir=subdir
+            )
+
+            if firstTime:
+                builder.writePackageInfoFile(
+                    outputDir,
+                    settings={
+                        'PackageName': f'PhysX-4.1.2.29882248-rev3-{args.platformName}',
+                        'URL': 'https://github.com/NVIDIAGameWorks/PhysX',
+                        'License': 'BSD-3-Clause',
+                        'LicenseFile': 'PhysX/LICENSE.md'
+                    },
+                )
+
+                builder.writeCMakeFindFile(
+                    outputDir,
+                    template=cmakeFindFileTemplate,
+                    templateEnv=extraLibsPerPlatform[args.platformName],
+                )
+
+            firstTime = False
+
+if __name__ == '__main__':
+    main()

+ 23 - 0
package-system/SPIRVCross/FindSPIRVCross.cmake.Linux

@@ -0,0 +1,23 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "SPIRVCross")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/SPIRVCross")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+set($${MY_NAME}_RUNTIME_DEPENDENCIES $${$${MY_NAME}_BINARY_DIR}/Release/spirv-cross)
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY $${output_subfolder} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 24 - 0
package-system/SPIRVCross/FindSPIRVCross.cmake.Mac

@@ -0,0 +1,24 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "SPIRVCross")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/SPIRVCross")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+set($${MY_NAME}_RUNTIME_DEPENDENCIES $${$${MY_NAME}_BINARY_DIR}/Release/spirv-cross)
+
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY $${output_subfolder} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 24 - 0
package-system/SPIRVCross/FindSPIRVCross.cmake.Windows

@@ -0,0 +1,24 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "SPIRVCross")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(output_subfolder "Builders/SPIRVCross")
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/$${MY_NAME}/bin)
+
+set($${MY_NAME}_RUNTIME_DEPENDENCIES $${$${MY_NAME}_BINARY_DIR}/Release/spirv-cross.exe)
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} OUTPUT_SUBDIRECTORY $${output_subfolder} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 101 - 0
package-system/SPIRVCross/build_config.json

@@ -0,0 +1,101 @@
+{
+   "git_url":"https://github.com/aws-lumberyard/SPIRV-Cross.git",
+   "git_tag":"release-2021.04.29",
+   "package_name":"SPIRVCross",
+   "package_version":"2021.04.29-rev1",
+   "package_url":"https://github.com/aws-lumberyard/SPIRV-Cross",
+   "package_license":"Apache-2.0",
+   "package_license_file":"LICENSE",
+   "cmake_find_target":"FindSPIRVCross.cmake",
+   "Platforms":{
+      "Windows":{
+         "Windows":{
+            "cmake_find_template":"FindSPIRVCross.cmake.Windows",
+            "cmake_generate_args_debug":[
+               "-G",
+               "\"Visual Studio 16 2019\"",
+               "-A",
+               "x64",
+               "-T",
+               "host=x64",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "\"Visual Studio 16 2019\"",
+               "-A",
+               "x64",
+               "-T",
+               "host=x64",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ]
+         }
+      },
+      "Darwin":{
+         "Mac":{
+            "cmake_find_template":"FindSPIRVCross.cmake.Mac",
+            "cmake_generate_args_debug":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j",
+               "8"
+            ]
+         }
+      },
+      "Linux":{
+         "Linux":{
+            "cmake_find_template":"FindSPIRVCross.cmake.Linux",
+            "cmake_generate_args_debug":[
+               "-G",
+               "Ninja",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Ninja",
+               "-DSPIRV_CROSS_CLI=ON",
+               "-DSPIRV_CROSS_SHARED=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_INSTALL_BINDIR=\"bin/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ]
+         }
+      }
+   }
+}

+ 16 - 0
package-system/glad-multiplatform/Findglad.cmake

@@ -0,0 +1,16 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "glad")
+set(TARGET_WITH_NAMESPACE "3rdParty::${MY_NAME}")
+set(${MY_NAME}_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/glad/include)
+
+add_library(${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_target_include_system_directories(TARGET ${TARGET_WITH_NAMESPACE} INTERFACE ${${MY_NAME}_INCLUDE_DIR})
+set(${MY_NAME}_FOUND True)

+ 6 - 0
package-system/glad-multiplatform/PackageInfo.json

@@ -0,0 +1,6 @@
+{
+    "PackageName" : "glad-2.0.0-beta-rev2-multiplatform",
+    "URL"         : "https://github.com/Dav1dde/glad",
+    "License"     : "MIT",
+    "LicenseFile" : "glad/LICENSE"
+}

+ 63 - 0
package-system/glad-multiplatform/glad/LICENSE

@@ -0,0 +1,63 @@
+The glad source code:
+
+    The MIT License (MIT)
+
+    Copyright (c) 2013-2020 David Herberth
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy of
+    this software and associated documentation files (the "Software"), to deal in
+    the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+    the Software, and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+The Khronos Specifications:
+
+    Copyright (c) 2013-2020 The Khronos Group Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+The EGL Specification and various headers:
+
+    Copyright (c) 2007-2016 The Khronos Group Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and/or associated documentation files (the
+    "Materials"), to deal in the Materials without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Materials, and to
+    permit persons to whom the Materials are furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Materials.
+
+    THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

ファイルの差分が大きいため隠しています
+ 19 - 0
package-system/glad-multiplatform/glad/include/glad/egl.h


ファイルの差分が大きいため隠しています
+ 19 - 0
package-system/glad-multiplatform/glad/include/glad/gl.h


ファイルの差分が大きいため隠しています
+ 19 - 0
package-system/glad-multiplatform/glad/include/glad/gles2.h


+ 1933 - 0
package-system/glad-multiplatform/glad/include/glad/glx.h

@@ -0,0 +1,1933 @@
+/**
+ * Loader generated by glad 2.0.0-beta on Thu Jan 24 22:46:56 2019
+ *
+ * Generator: C/C++
+ * Specification: glx
+ * Extensions: 63
+ *
+ * APIs:
+ *  - glx=1.4
+ *
+ * Options:
+ *  - MX_GLOBAL = False
+ *  - LOADER = True
+ *  - ALIAS = False
+ *  - HEADER_ONLY = True
+ *  - DEBUG = False
+ *  - MX = False
+ *
+ * Commandline:
+ *    --api='glx=1.4' --extensions='GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_no_error,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_no_config_context,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_MESA_swap_control,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index' c --loader --header-only
+ *
+ * Online:
+ *    http://glad.sh/#api=glx%3D1.4&extensions=GLX_3DFX_multisample%2CGLX_AMD_gpu_association%2CGLX_ARB_context_flush_control%2CGLX_ARB_create_context%2CGLX_ARB_create_context_no_error%2CGLX_ARB_create_context_profile%2CGLX_ARB_create_context_robustness%2CGLX_ARB_fbconfig_float%2CGLX_ARB_framebuffer_sRGB%2CGLX_ARB_get_proc_address%2CGLX_ARB_multisample%2CGLX_ARB_robustness_application_isolation%2CGLX_ARB_robustness_share_group_isolation%2CGLX_ARB_vertex_buffer_object%2CGLX_EXT_buffer_age%2CGLX_EXT_create_context_es2_profile%2CGLX_EXT_create_context_es_profile%2CGLX_EXT_fbconfig_packed_float%2CGLX_EXT_framebuffer_sRGB%2CGLX_EXT_import_context%2CGLX_EXT_libglvnd%2CGLX_EXT_no_config_context%2CGLX_EXT_stereo_tree%2CGLX_EXT_swap_control%2CGLX_EXT_swap_control_tear%2CGLX_EXT_texture_from_pixmap%2CGLX_EXT_visual_info%2CGLX_EXT_visual_rating%2CGLX_INTEL_swap_event%2CGLX_MESA_agp_offset%2CGLX_MESA_copy_sub_buffer%2CGLX_MESA_pixmap_colormap%2CGLX_MESA_query_renderer%2CGLX_MESA_release_buffers%2CGLX_MESA_set_3dfx_mode%2CGLX_MESA_swap_control%2CGLX_NV_copy_buffer%2CGLX_NV_copy_image%2CGLX_NV_delay_before_swap%2CGLX_NV_float_buffer%2CGLX_NV_multisample_coverage%2CGLX_NV_present_video%2CGLX_NV_robustness_video_memory_purge%2CGLX_NV_swap_group%2CGLX_NV_video_capture%2CGLX_NV_video_out%2CGLX_OML_swap_method%2CGLX_OML_sync_control%2CGLX_SGIS_blended_overlay%2CGLX_SGIS_multisample%2CGLX_SGIS_shared_multisample%2CGLX_SGIX_fbconfig%2CGLX_SGIX_hyperpipe%2CGLX_SGIX_pbuffer%2CGLX_SGIX_swap_barrier%2CGLX_SGIX_swap_group%2CGLX_SGIX_video_resize%2CGLX_SGIX_visual_select_group%2CGLX_SGI_cushion%2CGLX_SGI_make_current_read%2CGLX_SGI_swap_control%2CGLX_SGI_video_sync%2CGLX_SUN_get_transparent_index&generator=c&options=LOADER%2CHEADER_ONLY
+ *
+ */
+
+#ifndef GLAD_GLX_H_
+#define GLAD_GLX_H_
+
+#ifdef GLX_H
+    #error GLX header already included (API: glx), remove previous include!
+#endif
+#define GLX_H 1
+
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include <glad/gl.h>
+
+#define GLAD_GLX
+#define GLAD_OPTION_GLX_LOADER
+#define GLAD_OPTION_GLX_HEADER_ONLY
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#ifndef GLAD_PLATFORM_WIN32
+  #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+    #define GLAD_PLATFORM_WIN32 1
+  #else
+    #define GLAD_PLATFORM_WIN32 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_APPLE
+  #ifdef __APPLE__
+    #define GLAD_PLATFORM_APPLE 1
+  #else
+    #define GLAD_PLATFORM_APPLE 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_EMSCRIPTEN
+  #ifdef __EMSCRIPTEN__
+    #define GLAD_PLATFORM_EMSCRIPTEN 1
+  #else
+    #define GLAD_PLATFORM_EMSCRIPTEN 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+  #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+    #ifdef __has_include
+      #if __has_include(<winapifamily.h>)
+        #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+      #endif
+    #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+      #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+    #endif
+  #endif
+
+  #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+    #include <winapifamily.h>
+    #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      #define GLAD_PLATFORM_UWP 1
+    #endif
+  #endif
+
+  #ifndef GLAD_PLATFORM_UWP
+    #define GLAD_PLATFORM_UWP 0
+  #endif
+#endif
+
+#ifdef __GNUC__
+  #define GLAD_GNUC_EXTENSION __extension__
+#else
+  #define GLAD_GNUC_EXTENSION
+#endif
+
+#ifndef GLAD_API_CALL
+  #if defined(GLAD_API_CALL_EXPORT)
+    #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+      #if defined(GLAD_API_CALL_EXPORT_BUILD)
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllexport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllexport) extern
+        #endif
+      #else
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllimport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllimport) extern
+        #endif
+      #endif
+    #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+      #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
+    #else
+      #define GLAD_API_CALL extern
+    #endif
+  #else
+    #define GLAD_API_CALL extern
+  #endif
+#endif
+
+#ifdef APIENTRY
+  #define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+  #define GLAD_API_PTR __stdcall
+#else
+  #define GLAD_API_PTR
+#endif
+
+#ifndef GLAPI
+#define GLAPI GLAD_API_CALL
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY GLAD_API_PTR
+#endif
+
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+typedef void (*GLADapiproc)(void);
+
+typedef GLADapiproc (*GLADloadfunc)(const char *name);
+typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
+
+typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2
+#define GLX_3DFX_WINDOW_MODE_MESA 0x1
+#define GLX_ACCUM_ALPHA_SIZE 17
+#define GLX_ACCUM_BLUE_SIZE 16
+#define GLX_ACCUM_BUFFER_BIT 0x00000080
+#define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080
+#define GLX_ACCUM_GREEN_SIZE 15
+#define GLX_ACCUM_RED_SIZE 14
+#define GLX_ALPHA_SIZE 11
+#define GLX_AUX0_EXT 0x20E2
+#define GLX_AUX1_EXT 0x20E3
+#define GLX_AUX2_EXT 0x20E4
+#define GLX_AUX3_EXT 0x20E5
+#define GLX_AUX4_EXT 0x20E6
+#define GLX_AUX5_EXT 0x20E7
+#define GLX_AUX6_EXT 0x20E8
+#define GLX_AUX7_EXT 0x20E9
+#define GLX_AUX8_EXT 0x20EA
+#define GLX_AUX9_EXT 0x20EB
+#define GLX_AUX_BUFFERS 7
+#define GLX_AUX_BUFFERS_BIT 0x00000010
+#define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010
+#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
+#define GLX_BACK_EXT 0x20E0
+#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004
+#define GLX_BACK_LEFT_EXT 0x20E0
+#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008
+#define GLX_BACK_RIGHT_EXT 0x20E1
+#define GLX_BAD_ATTRIBUTE 2
+#define GLX_BAD_CONTEXT 5
+#define GLX_BAD_ENUM 7
+#define GLX_BAD_HYPERPIPE_CONFIG_SGIX 91
+#define GLX_BAD_HYPERPIPE_SGIX 92
+#define GLX_BAD_SCREEN 1
+#define GLX_BAD_VALUE 6
+#define GLX_BAD_VISUAL 4
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
+#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
+#define GLX_BLENDED_RGBA_SGIS 0x8025
+#define GLX_BLUE_SIZE 10
+#define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000
+#define GLX_BUFFER_SIZE 2
+#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
+#define GLX_BufferSwapComplete 1
+#define GLX_COLOR_INDEX_BIT 0x00000002
+#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002
+#define GLX_COLOR_INDEX_TYPE 0x8015
+#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015
+#define GLX_COLOR_SAMPLES_NV 0x20B3
+#define GLX_CONFIG_CAVEAT 0x20
+#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define GLX_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define GLX_CONTEXT_FLAGS_ARB 0x2094
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_CONTEXT_OPENGL_NO_ERROR_ARB 0x31B3
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GLX_COPY_COMPLETE_INTEL 0x8181
+#define GLX_COVERAGE_SAMPLES_NV 100001
+#define GLX_DAMAGED 0x8020
+#define GLX_DAMAGED_SGIX 0x8020
+#define GLX_DEPTH_BUFFER_BIT 0x00000020
+#define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020
+#define GLX_DEPTH_SIZE 12
+#define GLX_DEVICE_ID_NV 0x20CD
+#define GLX_DIRECT_COLOR 0x8003
+#define GLX_DIRECT_COLOR_EXT 0x8003
+#define GLX_DONT_CARE 0xFFFFFFFF
+#define GLX_DOUBLEBUFFER 5
+#define GLX_DRAWABLE_TYPE 0x8010
+#define GLX_DRAWABLE_TYPE_SGIX 0x8010
+#define GLX_EVENT_MASK 0x801F
+#define GLX_EVENT_MASK_SGIX 0x801F
+#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180
+#define GLX_EXTENSIONS 0x3
+#define GLX_EXTENSION_NAME "GLX"
+#define GLX_FBCONFIG_ID 0x8013
+#define GLX_FBCONFIG_ID_SGIX 0x8013
+#define GLX_FLIP_COMPLETE_INTEL 0x8182
+#define GLX_FLOAT_COMPONENTS_NV 0x20B0
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2
+#define GLX_FRONT_EXT 0x20DE
+#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001
+#define GLX_FRONT_LEFT_EXT 0x20DE
+#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002
+#define GLX_FRONT_RIGHT_EXT 0x20DF
+#define GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x20F7
+#define GLX_GPU_CLOCK_AMD 0x21A4
+#define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define GLX_GPU_NUM_PIPES_AMD 0x21A5
+#define GLX_GPU_NUM_RB_AMD 0x21A7
+#define GLX_GPU_NUM_SIMD_AMD 0x21A6
+#define GLX_GPU_NUM_SPI_AMD 0x21A8
+#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define GLX_GPU_RAM_AMD 0x21A3
+#define GLX_GPU_RENDERER_STRING_AMD 0x1F01
+#define GLX_GPU_VENDOR_AMD 0x1F00
+#define GLX_GRAY_SCALE 0x8006
+#define GLX_GRAY_SCALE_EXT 0x8006
+#define GLX_GREEN_SIZE 9
+#define GLX_HEIGHT 0x801E
+#define GLX_HEIGHT_SGIX 0x801E
+#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX 0x00000001
+#define GLX_HYPERPIPE_ID_SGIX 0x8030
+#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
+#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX 0x00000004
+#define GLX_HYPERPIPE_RENDER_PIPE_SGIX 0x00000002
+#define GLX_HYPERPIPE_STEREO_SGIX 0x00000003
+#define GLX_LARGEST_PBUFFER 0x801C
+#define GLX_LARGEST_PBUFFER_SGIX 0x801C
+#define GLX_LATE_SWAPS_TEAR_EXT 0x20F3
+#define GLX_LEVEL 3
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GLX_MAX_PBUFFER_HEIGHT 0x8017
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017
+#define GLX_MAX_PBUFFER_PIXELS 0x8018
+#define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018
+#define GLX_MAX_PBUFFER_WIDTH 0x8016
+#define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016
+#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2
+#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_NONE 0x8000
+#define GLX_NONE_EXT 0x8000
+#define GLX_NON_CONFORMANT_CONFIG 0x800D
+#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
+#define GLX_NO_EXTENSION 3
+#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
+#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#define GLX_NUM_VIDEO_SLOTS_NV 0x20F0
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019
+#define GLX_PBUFFER 0x8023
+#define GLX_PBUFFER_BIT 0x00000004
+#define GLX_PBUFFER_BIT_SGIX 0x00000004
+#define GLX_PBUFFER_CLOBBER_MASK 0x08000000
+#define GLX_PBUFFER_HEIGHT 0x8040
+#define GLX_PBUFFER_SGIX 0x8023
+#define GLX_PBUFFER_WIDTH 0x8041
+#define GLX_PIPE_RECT_LIMITS_SGIX 0x00000002
+#define GLX_PIPE_RECT_SGIX 0x00000001
+#define GLX_PIXMAP_BIT 0x00000002
+#define GLX_PIXMAP_BIT_SGIX 0x00000002
+#define GLX_PRESERVED_CONTENTS 0x801B
+#define GLX_PRESERVED_CONTENTS_SGIX 0x801B
+#define GLX_PSEUDO_COLOR 0x8004
+#define GLX_PSEUDO_COLOR_EXT 0x8004
+#define GLX_PbufferClobber 0
+#define GLX_RED_SIZE 8
+#define GLX_RENDERER_ACCELERATED_MESA 0x8186
+#define GLX_RENDERER_DEVICE_ID_MESA 0x8184
+#define GLX_RENDERER_ID_MESA 0x818E
+#define GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA 0x818B
+#define GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA 0x818A
+#define GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA 0x818D
+#define GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA 0x818C
+#define GLX_RENDERER_PREFERRED_PROFILE_MESA 0x8189
+#define GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA 0x8188
+#define GLX_RENDERER_VENDOR_ID_MESA 0x8183
+#define GLX_RENDERER_VERSION_MESA 0x8185
+#define GLX_RENDERER_VIDEO_MEMORY_MESA 0x8187
+#define GLX_RENDER_TYPE 0x8011
+#define GLX_RENDER_TYPE_SGIX 0x8011
+#define GLX_RGBA 4
+#define GLX_RGBA_BIT 0x00000001
+#define GLX_RGBA_BIT_SGIX 0x00000001
+#define GLX_RGBA_FLOAT_BIT_ARB 0x00000004
+#define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9
+#define GLX_RGBA_TYPE 0x8014
+#define GLX_RGBA_TYPE_SGIX 0x8014
+#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
+#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
+#define GLX_SAMPLES 100001
+#define GLX_SAMPLES_3DFX 0x8051
+#define GLX_SAMPLES_ARB 100001
+#define GLX_SAMPLES_SGIS 100001
+#define GLX_SAMPLE_BUFFERS 100000
+#define GLX_SAMPLE_BUFFERS_3DFX 0x8050
+#define GLX_SAMPLE_BUFFERS_ARB 100000
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100
+#define GLX_SAMPLE_BUFFERS_SGIS 100000
+#define GLX_SAVED 0x8021
+#define GLX_SAVED_SGIX 0x8021
+#define GLX_SCREEN 0x800C
+#define GLX_SCREEN_EXT 0x800C
+#define GLX_SHARE_CONTEXT_EXT 0x800A
+#define GLX_SLOW_CONFIG 0x8001
+#define GLX_SLOW_VISUAL_EXT 0x8001
+#define GLX_STATIC_COLOR 0x8005
+#define GLX_STATIC_COLOR_EXT 0x8005
+#define GLX_STATIC_GRAY 0x8007
+#define GLX_STATIC_GRAY_EXT 0x8007
+#define GLX_STENCIL_BUFFER_BIT 0x00000040
+#define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040
+#define GLX_STENCIL_SIZE 13
+#define GLX_STEREO 6
+#define GLX_STEREO_NOTIFY_EXT 0x00000000
+#define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001
+#define GLX_STEREO_TREE_EXT 0x20F5
+#define GLX_SWAP_COPY_OML 0x8062
+#define GLX_SWAP_EXCHANGE_OML 0x8061
+#define GLX_SWAP_INTERVAL_EXT 0x20F1
+#define GLX_SWAP_METHOD_OML 0x8060
+#define GLX_SWAP_UNDEFINED_OML 0x8063
+#define GLX_SYNC_FRAME_SGIX 0x00000000
+#define GLX_SYNC_SWAP_SGIX 0x00000001
+#define GLX_TEXTURE_1D_BIT_EXT 0x00000001
+#define GLX_TEXTURE_1D_EXT 0x20DB
+#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
+#define GLX_TEXTURE_2D_EXT 0x20DC
+#define GLX_TEXTURE_FORMAT_EXT 0x20D5
+#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
+#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
+#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
+#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
+#define GLX_TEXTURE_TARGET_EXT 0x20D6
+#define GLX_TRANSPARENT_ALPHA_VALUE 0x28
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28
+#define GLX_TRANSPARENT_BLUE_VALUE 0x27
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27
+#define GLX_TRANSPARENT_GREEN_VALUE 0x26
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26
+#define GLX_TRANSPARENT_INDEX 0x8009
+#define GLX_TRANSPARENT_INDEX_EXT 0x8009
+#define GLX_TRANSPARENT_INDEX_VALUE 0x24
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24
+#define GLX_TRANSPARENT_RED_VALUE 0x25
+#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25
+#define GLX_TRANSPARENT_RGB 0x8008
+#define GLX_TRANSPARENT_RGB_EXT 0x8008
+#define GLX_TRANSPARENT_TYPE 0x23
+#define GLX_TRANSPARENT_TYPE_EXT 0x23
+#define GLX_TRUE_COLOR 0x8002
+#define GLX_TRUE_COLOR_EXT 0x8002
+#define GLX_UNIQUE_ID_NV 0x20CE
+#define GLX_USE_GL 1
+#define GLX_VENDOR 0x1
+#define GLX_VENDOR_NAMES_EXT 0x20F6
+#define GLX_VERSION 0x2
+#define GLX_VIDEO_OUT_ALPHA_NV 0x20C4
+#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define GLX_VIDEO_OUT_COLOR_NV 0x20C3
+#define GLX_VIDEO_OUT_DEPTH_NV 0x20C5
+#define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9
+#define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA
+#define GLX_VIDEO_OUT_FRAME_NV 0x20C8
+#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB
+#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC
+#define GLX_VISUAL_CAVEAT_EXT 0x20
+#define GLX_VISUAL_ID 0x800B
+#define GLX_VISUAL_ID_EXT 0x800B
+#define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028
+#define GLX_WIDTH 0x801D
+#define GLX_WIDTH_SGIX 0x801D
+#define GLX_WINDOW 0x8022
+#define GLX_WINDOW_BIT 0x00000001
+#define GLX_WINDOW_BIT_SGIX 0x00000001
+#define GLX_WINDOW_SGIX 0x8022
+#define GLX_X_RENDERABLE 0x8012
+#define GLX_X_RENDERABLE_SGIX 0x8012
+#define GLX_X_VISUAL_TYPE 0x22
+#define GLX_X_VISUAL_TYPE_EXT 0x22
+#define GLX_Y_INVERTED_EXT 0x20D4
+#define __GLX_NUMBER_EVENTS 17
+
+
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GLX_OML_sync_control extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+
+#else
+
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+
+#else
+
+#endif
+
+
+
+
+
+
+
+typedef XID GLXFBConfigID;
+typedef struct __GLXFBConfigRec *GLXFBConfig;
+typedef XID GLXContextID;
+typedef struct __GLXcontextRec *GLXContext;
+typedef XID GLXPixmap;
+typedef XID GLXDrawable;
+typedef XID GLXWindow;
+typedef XID GLXPbuffer;
+typedef void ( *__GLXextFuncPtr)(void);
+typedef XID GLXVideoCaptureDeviceNV;
+typedef unsigned int GLXVideoDeviceNV;
+typedef XID GLXVideoSourceSGIX;
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+typedef XID GLXPbufferSGIX;
+typedef struct {
+    int event_type;             /* GLX_DAMAGED or GLX_SAVED */
+    int draw_type;              /* GLX_WINDOW or GLX_PBUFFER */
+    unsigned long serial;       /* # of last request processed by server */
+    Bool send_event;            /* true if this came for SendEvent request */
+    Display *display;           /* display the event was read from */
+    GLXDrawable drawable;       /* XID of Drawable */
+    unsigned int buffer_mask;   /* mask indicating which buffers are affected */
+    unsigned int aux_buffer;    /* which aux buffer was affected */
+    int x, y;
+    int width, height;
+    int count;                  /* if nonzero, at least this many more */
+} GLXPbufferClobberEvent;
+typedef struct {
+    int type;
+    unsigned long serial;       /* # of last request processed by server */
+    Bool send_event;            /* true if this came from a SendEvent request */
+    Display *display;           /* Display the event was read from */
+    GLXDrawable drawable;       /* drawable on which event was requested in event mask */
+    int event_type;
+    int64_t ust;
+    int64_t msc;
+    int64_t sbc;
+} GLXBufferSwapComplete;
+typedef union __GLXEvent {
+    GLXPbufferClobberEvent glxpbufferclobber;
+    GLXBufferSwapComplete glxbufferswapcomplete;
+    long pad[24];
+} GLXEvent;
+typedef struct {
+    int type;
+    unsigned long serial;
+    Bool send_event;
+    Display *display;
+    int extension;
+    int evtype;
+    GLXDrawable window;
+    Bool stereo_tree;
+} GLXStereoNotifyEventEXT;
+typedef struct {
+    int type;
+    unsigned long serial;   /* # of last request processed by server */
+    Bool send_event;        /* true if this came for SendEvent request */
+    Display *display;       /* display the event was read from */
+    GLXDrawable drawable;   /* i.d. of Drawable */
+    int event_type;         /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+    int draw_type;          /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+    unsigned int mask;      /* mask indicating which buffers are affected*/
+    int x, y;
+    int width, height;
+    int count;              /* if nonzero, at least this many more */
+} GLXBufferClobberEventSGIX;
+typedef struct {
+    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int     networkId;
+} GLXHyperpipeNetworkSGIX;
+typedef struct {
+    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int     channel;
+    unsigned int participationType;
+    int     timeSlice;
+} GLXHyperpipeConfigSGIX;
+typedef struct {
+    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+    int destXOrigin, destYOrigin, destWidth, destHeight;
+} GLXPipeRect;
+typedef struct {
+    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int XOrigin, YOrigin, maxHeight, maxWidth;
+} GLXPipeRectLimits;
+
+
+#define GLX_VERSION_1_0 1
+GLAD_API_CALL int GLAD_GLX_VERSION_1_0;
+#define GLX_VERSION_1_1 1
+GLAD_API_CALL int GLAD_GLX_VERSION_1_1;
+#define GLX_VERSION_1_2 1
+GLAD_API_CALL int GLAD_GLX_VERSION_1_2;
+#define GLX_VERSION_1_3 1
+GLAD_API_CALL int GLAD_GLX_VERSION_1_3;
+#define GLX_VERSION_1_4 1
+GLAD_API_CALL int GLAD_GLX_VERSION_1_4;
+#define GLX_3DFX_multisample 1
+GLAD_API_CALL int GLAD_GLX_3DFX_multisample;
+#define GLX_AMD_gpu_association 1
+GLAD_API_CALL int GLAD_GLX_AMD_gpu_association;
+#define GLX_ARB_context_flush_control 1
+GLAD_API_CALL int GLAD_GLX_ARB_context_flush_control;
+#define GLX_ARB_create_context 1
+GLAD_API_CALL int GLAD_GLX_ARB_create_context;
+#define GLX_ARB_create_context_no_error 1
+GLAD_API_CALL int GLAD_GLX_ARB_create_context_no_error;
+#define GLX_ARB_create_context_profile 1
+GLAD_API_CALL int GLAD_GLX_ARB_create_context_profile;
+#define GLX_ARB_create_context_robustness 1
+GLAD_API_CALL int GLAD_GLX_ARB_create_context_robustness;
+#define GLX_ARB_fbconfig_float 1
+GLAD_API_CALL int GLAD_GLX_ARB_fbconfig_float;
+#define GLX_ARB_framebuffer_sRGB 1
+GLAD_API_CALL int GLAD_GLX_ARB_framebuffer_sRGB;
+#define GLX_ARB_get_proc_address 1
+GLAD_API_CALL int GLAD_GLX_ARB_get_proc_address;
+#define GLX_ARB_multisample 1
+GLAD_API_CALL int GLAD_GLX_ARB_multisample;
+#define GLX_ARB_robustness_application_isolation 1
+GLAD_API_CALL int GLAD_GLX_ARB_robustness_application_isolation;
+#define GLX_ARB_robustness_share_group_isolation 1
+GLAD_API_CALL int GLAD_GLX_ARB_robustness_share_group_isolation;
+#define GLX_ARB_vertex_buffer_object 1
+GLAD_API_CALL int GLAD_GLX_ARB_vertex_buffer_object;
+#define GLX_EXT_buffer_age 1
+GLAD_API_CALL int GLAD_GLX_EXT_buffer_age;
+#define GLX_EXT_create_context_es2_profile 1
+GLAD_API_CALL int GLAD_GLX_EXT_create_context_es2_profile;
+#define GLX_EXT_create_context_es_profile 1
+GLAD_API_CALL int GLAD_GLX_EXT_create_context_es_profile;
+#define GLX_EXT_fbconfig_packed_float 1
+GLAD_API_CALL int GLAD_GLX_EXT_fbconfig_packed_float;
+#define GLX_EXT_framebuffer_sRGB 1
+GLAD_API_CALL int GLAD_GLX_EXT_framebuffer_sRGB;
+#define GLX_EXT_import_context 1
+GLAD_API_CALL int GLAD_GLX_EXT_import_context;
+#define GLX_EXT_libglvnd 1
+GLAD_API_CALL int GLAD_GLX_EXT_libglvnd;
+#define GLX_EXT_no_config_context 1
+GLAD_API_CALL int GLAD_GLX_EXT_no_config_context;
+#define GLX_EXT_stereo_tree 1
+GLAD_API_CALL int GLAD_GLX_EXT_stereo_tree;
+#define GLX_EXT_swap_control 1
+GLAD_API_CALL int GLAD_GLX_EXT_swap_control;
+#define GLX_EXT_swap_control_tear 1
+GLAD_API_CALL int GLAD_GLX_EXT_swap_control_tear;
+#define GLX_EXT_texture_from_pixmap 1
+GLAD_API_CALL int GLAD_GLX_EXT_texture_from_pixmap;
+#define GLX_EXT_visual_info 1
+GLAD_API_CALL int GLAD_GLX_EXT_visual_info;
+#define GLX_EXT_visual_rating 1
+GLAD_API_CALL int GLAD_GLX_EXT_visual_rating;
+#define GLX_INTEL_swap_event 1
+GLAD_API_CALL int GLAD_GLX_INTEL_swap_event;
+#define GLX_MESA_agp_offset 1
+GLAD_API_CALL int GLAD_GLX_MESA_agp_offset;
+#define GLX_MESA_copy_sub_buffer 1
+GLAD_API_CALL int GLAD_GLX_MESA_copy_sub_buffer;
+#define GLX_MESA_pixmap_colormap 1
+GLAD_API_CALL int GLAD_GLX_MESA_pixmap_colormap;
+#define GLX_MESA_query_renderer 1
+GLAD_API_CALL int GLAD_GLX_MESA_query_renderer;
+#define GLX_MESA_release_buffers 1
+GLAD_API_CALL int GLAD_GLX_MESA_release_buffers;
+#define GLX_MESA_set_3dfx_mode 1
+GLAD_API_CALL int GLAD_GLX_MESA_set_3dfx_mode;
+#define GLX_MESA_swap_control 1
+GLAD_API_CALL int GLAD_GLX_MESA_swap_control;
+#define GLX_NV_copy_buffer 1
+GLAD_API_CALL int GLAD_GLX_NV_copy_buffer;
+#define GLX_NV_copy_image 1
+GLAD_API_CALL int GLAD_GLX_NV_copy_image;
+#define GLX_NV_delay_before_swap 1
+GLAD_API_CALL int GLAD_GLX_NV_delay_before_swap;
+#define GLX_NV_float_buffer 1
+GLAD_API_CALL int GLAD_GLX_NV_float_buffer;
+#define GLX_NV_multisample_coverage 1
+GLAD_API_CALL int GLAD_GLX_NV_multisample_coverage;
+#define GLX_NV_present_video 1
+GLAD_API_CALL int GLAD_GLX_NV_present_video;
+#define GLX_NV_robustness_video_memory_purge 1
+GLAD_API_CALL int GLAD_GLX_NV_robustness_video_memory_purge;
+#define GLX_NV_swap_group 1
+GLAD_API_CALL int GLAD_GLX_NV_swap_group;
+#define GLX_NV_video_capture 1
+GLAD_API_CALL int GLAD_GLX_NV_video_capture;
+#define GLX_NV_video_out 1
+GLAD_API_CALL int GLAD_GLX_NV_video_out;
+#define GLX_OML_swap_method 1
+GLAD_API_CALL int GLAD_GLX_OML_swap_method;
+#define GLX_OML_sync_control 1
+GLAD_API_CALL int GLAD_GLX_OML_sync_control;
+#define GLX_SGIS_blended_overlay 1
+GLAD_API_CALL int GLAD_GLX_SGIS_blended_overlay;
+#define GLX_SGIS_multisample 1
+GLAD_API_CALL int GLAD_GLX_SGIS_multisample;
+#define GLX_SGIS_shared_multisample 1
+GLAD_API_CALL int GLAD_GLX_SGIS_shared_multisample;
+#define GLX_SGIX_fbconfig 1
+GLAD_API_CALL int GLAD_GLX_SGIX_fbconfig;
+#define GLX_SGIX_hyperpipe 1
+GLAD_API_CALL int GLAD_GLX_SGIX_hyperpipe;
+#define GLX_SGIX_pbuffer 1
+GLAD_API_CALL int GLAD_GLX_SGIX_pbuffer;
+#define GLX_SGIX_swap_barrier 1
+GLAD_API_CALL int GLAD_GLX_SGIX_swap_barrier;
+#define GLX_SGIX_swap_group 1
+GLAD_API_CALL int GLAD_GLX_SGIX_swap_group;
+#define GLX_SGIX_video_resize 1
+GLAD_API_CALL int GLAD_GLX_SGIX_video_resize;
+#define GLX_SGIX_visual_select_group 1
+GLAD_API_CALL int GLAD_GLX_SGIX_visual_select_group;
+#define GLX_SGI_cushion 1
+GLAD_API_CALL int GLAD_GLX_SGI_cushion;
+#define GLX_SGI_make_current_read 1
+GLAD_API_CALL int GLAD_GLX_SGI_make_current_read;
+#define GLX_SGI_swap_control 1
+GLAD_API_CALL int GLAD_GLX_SGI_swap_control;
+#define GLX_SGI_video_sync 1
+GLAD_API_CALL int GLAD_GLX_SGI_video_sync;
+#define GLX_SUN_get_transparent_index 1
+GLAD_API_CALL int GLAD_GLX_SUN_get_transparent_index;
+
+
+typedef int (GLAD_API_PTR *PFNGLXBINDCHANNELTOWINDOWSGIXPROC)(Display  * display, int  screen, int  channel, Window   window);
+typedef int (GLAD_API_PTR *PFNGLXBINDHYPERPIPESGIXPROC)(Display  * dpy, int  hpId);
+typedef Bool (GLAD_API_PTR *PFNGLXBINDSWAPBARRIERNVPROC)(Display  * dpy, GLuint   group, GLuint   barrier);
+typedef void (GLAD_API_PTR *PFNGLXBINDSWAPBARRIERSGIXPROC)(Display  * dpy, GLXDrawable   drawable, int  barrier);
+typedef void (GLAD_API_PTR *PFNGLXBINDTEXIMAGEEXTPROC)(Display  * dpy, GLXDrawable   drawable, int  buffer, const int * attrib_list);
+typedef int (GLAD_API_PTR *PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)(Display  * dpy, unsigned int  video_capture_slot, GLXVideoCaptureDeviceNV   device);
+typedef int (GLAD_API_PTR *PFNGLXBINDVIDEODEVICENVPROC)(Display  * dpy, unsigned int  video_slot, unsigned int  video_device, const int * attrib_list);
+typedef int (GLAD_API_PTR *PFNGLXBINDVIDEOIMAGENVPROC)(Display  * dpy, GLXVideoDeviceNV   VideoDevice, GLXPbuffer   pbuf, int  iVideoBuffer);
+typedef void (GLAD_API_PTR *PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)(GLXContext   dstCtx, GLint   srcX0, GLint   srcY0, GLint   srcX1, GLint   srcY1, GLint   dstX0, GLint   dstY0, GLint   dstX1, GLint   dstY1, GLbitfield   mask, GLenum   filter);
+typedef int (GLAD_API_PTR *PFNGLXCHANNELRECTSGIXPROC)(Display  * display, int  screen, int  channel, int  x, int  y, int  w, int  h);
+typedef int (GLAD_API_PTR *PFNGLXCHANNELRECTSYNCSGIXPROC)(Display  * display, int  screen, int  channel, GLenum   synctype);
+typedef GLXFBConfig * (GLAD_API_PTR *PFNGLXCHOOSEFBCONFIGPROC)(Display  * dpy, int  screen, const int * attrib_list, int * nelements);
+typedef GLXFBConfigSGIX * (GLAD_API_PTR *PFNGLXCHOOSEFBCONFIGSGIXPROC)(Display  * dpy, int  screen, int * attrib_list, int * nelements);
+typedef XVisualInfo * (GLAD_API_PTR *PFNGLXCHOOSEVISUALPROC)(Display  * dpy, int  screen, int * attribList);
+typedef void (GLAD_API_PTR *PFNGLXCOPYBUFFERSUBDATANVPROC)(Display  * dpy, GLXContext   readCtx, GLXContext   writeCtx, GLenum   readTarget, GLenum   writeTarget, GLintptr   readOffset, GLintptr   writeOffset, GLsizeiptr   size);
+typedef void (GLAD_API_PTR *PFNGLXCOPYCONTEXTPROC)(Display  * dpy, GLXContext   src, GLXContext   dst, unsigned long  mask);
+typedef void (GLAD_API_PTR *PFNGLXCOPYIMAGESUBDATANVPROC)(Display  * dpy, GLXContext   srcCtx, GLuint   srcName, GLenum   srcTarget, GLint   srcLevel, GLint   srcX, GLint   srcY, GLint   srcZ, GLXContext   dstCtx, GLuint   dstName, GLenum   dstTarget, GLint   dstLevel, GLint   dstX, GLint   dstY, GLint   dstZ, GLsizei   width, GLsizei   height, GLsizei   depth);
+typedef void (GLAD_API_PTR *PFNGLXCOPYSUBBUFFERMESAPROC)(Display  * dpy, GLXDrawable   drawable, int  x, int  y, int  width, int  height);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)(unsigned int  id, GLXContext   share_list);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(unsigned int  id, GLXContext   share_context, const int * attribList);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATECONTEXTPROC)(Display  * dpy, XVisualInfo  * vis, GLXContext   shareList, Bool   direct);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display  * dpy, GLXFBConfig   config, GLXContext   share_context, Bool   direct, const int * attrib_list);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)(Display  * dpy, GLXFBConfigSGIX   config, int  render_type, GLXContext   share_list, Bool   direct);
+typedef GLXPbufferSGIX (GLAD_API_PTR *PFNGLXCREATEGLXPBUFFERSGIXPROC)(Display  * dpy, GLXFBConfigSGIX   config, unsigned int  width, unsigned int  height, int * attrib_list);
+typedef GLXPixmap (GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPPROC)(Display  * dpy, XVisualInfo  * visual, Pixmap   pixmap);
+typedef GLXPixmap (GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPMESAPROC)(Display  * dpy, XVisualInfo  * visual, Pixmap   pixmap, Colormap   cmap);
+typedef GLXPixmap (GLAD_API_PTR *PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)(Display  * dpy, GLXFBConfigSGIX   config, Pixmap   pixmap);
+typedef GLXContext (GLAD_API_PTR *PFNGLXCREATENEWCONTEXTPROC)(Display  * dpy, GLXFBConfig   config, int  render_type, GLXContext   share_list, Bool   direct);
+typedef GLXPbuffer (GLAD_API_PTR *PFNGLXCREATEPBUFFERPROC)(Display  * dpy, GLXFBConfig   config, const int * attrib_list);
+typedef GLXPixmap (GLAD_API_PTR *PFNGLXCREATEPIXMAPPROC)(Display  * dpy, GLXFBConfig   config, Pixmap   pixmap, const int * attrib_list);
+typedef GLXWindow (GLAD_API_PTR *PFNGLXCREATEWINDOWPROC)(Display  * dpy, GLXFBConfig   config, Window   win, const int * attrib_list);
+typedef void (GLAD_API_PTR *PFNGLXCUSHIONSGIPROC)(Display  * dpy, Window   window, float  cushion);
+typedef Bool (GLAD_API_PTR *PFNGLXDELAYBEFORESWAPNVPROC)(Display  * dpy, GLXDrawable   drawable, GLfloat   seconds);
+typedef Bool (GLAD_API_PTR *PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)(GLXContext   ctx);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYCONTEXTPROC)(Display  * dpy, GLXContext   ctx);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYGLXPBUFFERSGIXPROC)(Display  * dpy, GLXPbufferSGIX   pbuf);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYGLXPIXMAPPROC)(Display  * dpy, GLXPixmap   pixmap);
+typedef int (GLAD_API_PTR *PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)(Display  * dpy, int  hpId);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYPBUFFERPROC)(Display  * dpy, GLXPbuffer   pbuf);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYPIXMAPPROC)(Display  * dpy, GLXPixmap   pixmap);
+typedef void (GLAD_API_PTR *PFNGLXDESTROYWINDOWPROC)(Display  * dpy, GLXWindow   win);
+typedef GLXVideoCaptureDeviceNV * (GLAD_API_PTR *PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)(Display  * dpy, int  screen, int * nelements);
+typedef unsigned int * (GLAD_API_PTR *PFNGLXENUMERATEVIDEODEVICESNVPROC)(Display  * dpy, int  screen, int * nelements);
+typedef void (GLAD_API_PTR *PFNGLXFREECONTEXTEXTPROC)(Display  * dpy, GLXContext   context);
+typedef unsigned int (GLAD_API_PTR *PFNGLXGETAGPOFFSETMESAPROC)(const void * pointer);
+typedef const char * (GLAD_API_PTR *PFNGLXGETCLIENTSTRINGPROC)(Display  * dpy, int  name);
+typedef int (GLAD_API_PTR *PFNGLXGETCONFIGPROC)(Display  * dpy, XVisualInfo  * visual, int  attrib, int * value);
+typedef unsigned int (GLAD_API_PTR *PFNGLXGETCONTEXTGPUIDAMDPROC)(GLXContext   ctx);
+typedef GLXContextID (GLAD_API_PTR *PFNGLXGETCONTEXTIDEXTPROC)(const  GLXContext   context);
+typedef GLXContext (GLAD_API_PTR *PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)(void);
+typedef GLXContext (GLAD_API_PTR *PFNGLXGETCURRENTCONTEXTPROC)(void);
+typedef Display * (GLAD_API_PTR *PFNGLXGETCURRENTDISPLAYPROC)(void);
+typedef Display * (GLAD_API_PTR *PFNGLXGETCURRENTDISPLAYEXTPROC)(void);
+typedef GLXDrawable (GLAD_API_PTR *PFNGLXGETCURRENTDRAWABLEPROC)(void);
+typedef GLXDrawable (GLAD_API_PTR *PFNGLXGETCURRENTREADDRAWABLEPROC)(void);
+typedef GLXDrawable (GLAD_API_PTR *PFNGLXGETCURRENTREADDRAWABLESGIPROC)(void);
+typedef int (GLAD_API_PTR *PFNGLXGETFBCONFIGATTRIBPROC)(Display  * dpy, GLXFBConfig   config, int  attribute, int * value);
+typedef int (GLAD_API_PTR *PFNGLXGETFBCONFIGATTRIBSGIXPROC)(Display  * dpy, GLXFBConfigSGIX   config, int  attribute, int * value);
+typedef GLXFBConfigSGIX (GLAD_API_PTR *PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)(Display  * dpy, XVisualInfo  * vis);
+typedef GLXFBConfig * (GLAD_API_PTR *PFNGLXGETFBCONFIGSPROC)(Display  * dpy, int  screen, int * nelements);
+typedef unsigned int (GLAD_API_PTR *PFNGLXGETGPUIDSAMDPROC)(unsigned int  maxCount, unsigned int * ids);
+typedef int (GLAD_API_PTR *PFNGLXGETGPUINFOAMDPROC)(unsigned int  id, int  property, GLenum   dataType, unsigned int  size, void * data);
+typedef Bool (GLAD_API_PTR *PFNGLXGETMSCRATEOMLPROC)(Display  * dpy, GLXDrawable   drawable, int32_t  * numerator, int32_t  * denominator);
+typedef __GLXextFuncPtr (GLAD_API_PTR *PFNGLXGETPROCADDRESSPROC)(const  GLubyte  * procName);
+typedef __GLXextFuncPtr (GLAD_API_PTR *PFNGLXGETPROCADDRESSARBPROC)(const  GLubyte  * procName);
+typedef void (GLAD_API_PTR *PFNGLXGETSELECTEDEVENTPROC)(Display  * dpy, GLXDrawable   draw, unsigned long * event_mask);
+typedef void (GLAD_API_PTR *PFNGLXGETSELECTEDEVENTSGIXPROC)(Display  * dpy, GLXDrawable   drawable, unsigned long * mask);
+typedef int (GLAD_API_PTR *PFNGLXGETSWAPINTERVALMESAPROC)(void);
+typedef Bool (GLAD_API_PTR *PFNGLXGETSYNCVALUESOMLPROC)(Display  * dpy, GLXDrawable   drawable, int64_t  * ust, int64_t  * msc, int64_t  * sbc);
+typedef Status (GLAD_API_PTR *PFNGLXGETTRANSPARENTINDEXSUNPROC)(Display  * dpy, Window   overlay, Window   underlay, long * pTransparentIndex);
+typedef int (GLAD_API_PTR *PFNGLXGETVIDEODEVICENVPROC)(Display  * dpy, int  screen, int  numVideoDevices, GLXVideoDeviceNV  * pVideoDevice);
+typedef int (GLAD_API_PTR *PFNGLXGETVIDEOINFONVPROC)(Display  * dpy, int  screen, GLXVideoDeviceNV   VideoDevice, unsigned long * pulCounterOutputPbuffer, unsigned long * pulCounterOutputVideo);
+typedef int (GLAD_API_PTR *PFNGLXGETVIDEOSYNCSGIPROC)(unsigned int * count);
+typedef XVisualInfo * (GLAD_API_PTR *PFNGLXGETVISUALFROMFBCONFIGPROC)(Display  * dpy, GLXFBConfig   config);
+typedef XVisualInfo * (GLAD_API_PTR *PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)(Display  * dpy, GLXFBConfigSGIX   config);
+typedef int (GLAD_API_PTR *PFNGLXHYPERPIPEATTRIBSGIXPROC)(Display  * dpy, int  timeSlice, int  attrib, int  size, void * attribList);
+typedef int (GLAD_API_PTR *PFNGLXHYPERPIPECONFIGSGIXPROC)(Display  * dpy, int  networkId, int  npipes, GLXHyperpipeConfigSGIX  * cfg, int * hpId);
+typedef GLXContext (GLAD_API_PTR *PFNGLXIMPORTCONTEXTEXTPROC)(Display  * dpy, GLXContextID   contextID);
+typedef Bool (GLAD_API_PTR *PFNGLXISDIRECTPROC)(Display  * dpy, GLXContext   ctx);
+typedef Bool (GLAD_API_PTR *PFNGLXJOINSWAPGROUPNVPROC)(Display  * dpy, GLXDrawable   drawable, GLuint   group);
+typedef void (GLAD_API_PTR *PFNGLXJOINSWAPGROUPSGIXPROC)(Display  * dpy, GLXDrawable   drawable, GLXDrawable   member);
+typedef void (GLAD_API_PTR *PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)(Display  * dpy, GLXVideoCaptureDeviceNV   device);
+typedef Bool (GLAD_API_PTR *PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(GLXContext   ctx);
+typedef Bool (GLAD_API_PTR *PFNGLXMAKECONTEXTCURRENTPROC)(Display  * dpy, GLXDrawable   draw, GLXDrawable   read, GLXContext   ctx);
+typedef Bool (GLAD_API_PTR *PFNGLXMAKECURRENTPROC)(Display  * dpy, GLXDrawable   drawable, GLXContext   ctx);
+typedef Bool (GLAD_API_PTR *PFNGLXMAKECURRENTREADSGIPROC)(Display  * dpy, GLXDrawable   draw, GLXDrawable   read, GLXContext   ctx);
+typedef void (GLAD_API_PTR *PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)(Display  * dpy, GLXContext   readCtx, GLXContext   writeCtx, GLuint   readBuffer, GLuint   writeBuffer, GLintptr   readOffset, GLintptr   writeOffset, GLsizeiptr   size);
+typedef int (GLAD_API_PTR *PFNGLXQUERYCHANNELDELTASSGIXPROC)(Display  * display, int  screen, int  channel, int * x, int * y, int * w, int * h);
+typedef int (GLAD_API_PTR *PFNGLXQUERYCHANNELRECTSGIXPROC)(Display  * display, int  screen, int  channel, int * dx, int * dy, int * dw, int * dh);
+typedef int (GLAD_API_PTR *PFNGLXQUERYCONTEXTPROC)(Display  * dpy, GLXContext   ctx, int  attribute, int * value);
+typedef int (GLAD_API_PTR *PFNGLXQUERYCONTEXTINFOEXTPROC)(Display  * dpy, GLXContext   context, int  attribute, int * value);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)(int  attribute, unsigned int * value);
+typedef const char * (GLAD_API_PTR *PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)(int  attribute);
+typedef void (GLAD_API_PTR *PFNGLXQUERYDRAWABLEPROC)(Display  * dpy, GLXDrawable   draw, int  attribute, unsigned int * value);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYEXTENSIONPROC)(Display  * dpy, int * errorb, int * event);
+typedef const char * (GLAD_API_PTR *PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display  * dpy, int  screen);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYFRAMECOUNTNVPROC)(Display  * dpy, int  screen, GLuint  * count);
+typedef int (GLAD_API_PTR *PFNGLXQUERYGLXPBUFFERSGIXPROC)(Display  * dpy, GLXPbufferSGIX   pbuf, int  attribute, unsigned int * value);
+typedef int (GLAD_API_PTR *PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)(Display  * dpy, int  timeSlice, int  attrib, int  size, void * returnAttribList);
+typedef int (GLAD_API_PTR *PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)(Display  * dpy, int  timeSlice, int  attrib, int  size, void * attribList, void * returnAttribList);
+typedef GLXHyperpipeConfigSGIX * (GLAD_API_PTR *PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)(Display  * dpy, int  hpId, int * npipes);
+typedef GLXHyperpipeNetworkSGIX * (GLAD_API_PTR *PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)(Display  * dpy, int * npipes);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)(Display  * dpy, int  screen, int * max);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYMAXSWAPGROUPSNVPROC)(Display  * dpy, int  screen, GLuint  * maxGroups, GLuint  * maxBarriers);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYRENDERERINTEGERMESAPROC)(Display  * dpy, int  screen, int  renderer, int  attribute, unsigned int * value);
+typedef const char * (GLAD_API_PTR *PFNGLXQUERYRENDERERSTRINGMESAPROC)(Display  * dpy, int  screen, int  renderer, int  attribute);
+typedef const char * (GLAD_API_PTR *PFNGLXQUERYSERVERSTRINGPROC)(Display  * dpy, int  screen, int  name);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYSWAPGROUPNVPROC)(Display  * dpy, GLXDrawable   drawable, GLuint  * group, GLuint  * barrier);
+typedef Bool (GLAD_API_PTR *PFNGLXQUERYVERSIONPROC)(Display  * dpy, int * maj, int * min);
+typedef int (GLAD_API_PTR *PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)(Display  * dpy, GLXVideoCaptureDeviceNV   device, int  attribute, int * value);
+typedef Bool (GLAD_API_PTR *PFNGLXRELEASEBUFFERSMESAPROC)(Display  * dpy, GLXDrawable   drawable);
+typedef void (GLAD_API_PTR *PFNGLXRELEASETEXIMAGEEXTPROC)(Display  * dpy, GLXDrawable   drawable, int  buffer);
+typedef void (GLAD_API_PTR *PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)(Display  * dpy, GLXVideoCaptureDeviceNV   device);
+typedef int (GLAD_API_PTR *PFNGLXRELEASEVIDEODEVICENVPROC)(Display  * dpy, int  screen, GLXVideoDeviceNV   VideoDevice);
+typedef int (GLAD_API_PTR *PFNGLXRELEASEVIDEOIMAGENVPROC)(Display  * dpy, GLXPbuffer   pbuf);
+typedef Bool (GLAD_API_PTR *PFNGLXRESETFRAMECOUNTNVPROC)(Display  * dpy, int  screen);
+typedef void (GLAD_API_PTR *PFNGLXSELECTEVENTPROC)(Display  * dpy, GLXDrawable   draw, unsigned long  event_mask);
+typedef void (GLAD_API_PTR *PFNGLXSELECTEVENTSGIXPROC)(Display  * dpy, GLXDrawable   drawable, unsigned long  mask);
+typedef int (GLAD_API_PTR *PFNGLXSENDPBUFFERTOVIDEONVPROC)(Display  * dpy, GLXPbuffer   pbuf, int  iBufferType, unsigned long * pulCounterPbuffer, GLboolean   bBlock);
+typedef Bool (GLAD_API_PTR *PFNGLXSET3DFXMODEMESAPROC)(int  mode);
+typedef void (GLAD_API_PTR *PFNGLXSWAPBUFFERSPROC)(Display  * dpy, GLXDrawable   drawable);
+typedef int64_t (GLAD_API_PTR *PFNGLXSWAPBUFFERSMSCOMLPROC)(Display  * dpy, GLXDrawable   drawable, int64_t   target_msc, int64_t   divisor, int64_t   remainder);
+typedef void (GLAD_API_PTR *PFNGLXSWAPINTERVALEXTPROC)(Display  * dpy, GLXDrawable   drawable, int  interval);
+typedef int (GLAD_API_PTR *PFNGLXSWAPINTERVALMESAPROC)(unsigned int  interval);
+typedef int (GLAD_API_PTR *PFNGLXSWAPINTERVALSGIPROC)(int  interval);
+typedef void (GLAD_API_PTR *PFNGLXUSEXFONTPROC)(Font   font, int  first, int  count, int  list);
+typedef Bool (GLAD_API_PTR *PFNGLXWAITFORMSCOMLPROC)(Display  * dpy, GLXDrawable   drawable, int64_t   target_msc, int64_t   divisor, int64_t   remainder, int64_t  * ust, int64_t  * msc, int64_t  * sbc);
+typedef Bool (GLAD_API_PTR *PFNGLXWAITFORSBCOMLPROC)(Display  * dpy, GLXDrawable   drawable, int64_t   target_sbc, int64_t  * ust, int64_t  * msc, int64_t  * sbc);
+typedef void (GLAD_API_PTR *PFNGLXWAITGLPROC)(void);
+typedef int (GLAD_API_PTR *PFNGLXWAITVIDEOSYNCSGIPROC)(int  divisor, int  remainder, unsigned int * count);
+typedef void (GLAD_API_PTR *PFNGLXWAITXPROC)(void);
+
+GLAD_API_CALL PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX;
+#define glXBindChannelToWindowSGIX glad_glXBindChannelToWindowSGIX
+GLAD_API_CALL PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX;
+#define glXBindHyperpipeSGIX glad_glXBindHyperpipeSGIX
+GLAD_API_CALL PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV;
+#define glXBindSwapBarrierNV glad_glXBindSwapBarrierNV
+GLAD_API_CALL PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX;
+#define glXBindSwapBarrierSGIX glad_glXBindSwapBarrierSGIX
+GLAD_API_CALL PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT;
+#define glXBindTexImageEXT glad_glXBindTexImageEXT
+GLAD_API_CALL PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV;
+#define glXBindVideoCaptureDeviceNV glad_glXBindVideoCaptureDeviceNV
+GLAD_API_CALL PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV;
+#define glXBindVideoDeviceNV glad_glXBindVideoDeviceNV
+GLAD_API_CALL PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV;
+#define glXBindVideoImageNV glad_glXBindVideoImageNV
+GLAD_API_CALL PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD;
+#define glXBlitContextFramebufferAMD glad_glXBlitContextFramebufferAMD
+GLAD_API_CALL PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX;
+#define glXChannelRectSGIX glad_glXChannelRectSGIX
+GLAD_API_CALL PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX;
+#define glXChannelRectSyncSGIX glad_glXChannelRectSyncSGIX
+GLAD_API_CALL PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
+#define glXChooseFBConfig glad_glXChooseFBConfig
+GLAD_API_CALL PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX;
+#define glXChooseFBConfigSGIX glad_glXChooseFBConfigSGIX
+GLAD_API_CALL PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
+#define glXChooseVisual glad_glXChooseVisual
+GLAD_API_CALL PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV;
+#define glXCopyBufferSubDataNV glad_glXCopyBufferSubDataNV
+GLAD_API_CALL PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
+#define glXCopyContext glad_glXCopyContext
+GLAD_API_CALL PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV;
+#define glXCopyImageSubDataNV glad_glXCopyImageSubDataNV
+GLAD_API_CALL PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA;
+#define glXCopySubBufferMESA glad_glXCopySubBufferMESA
+GLAD_API_CALL PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD;
+#define glXCreateAssociatedContextAMD glad_glXCreateAssociatedContextAMD
+GLAD_API_CALL PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD;
+#define glXCreateAssociatedContextAttribsAMD glad_glXCreateAssociatedContextAttribsAMD
+GLAD_API_CALL PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
+#define glXCreateContext glad_glXCreateContext
+GLAD_API_CALL PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB;
+#define glXCreateContextAttribsARB glad_glXCreateContextAttribsARB
+GLAD_API_CALL PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX;
+#define glXCreateContextWithConfigSGIX glad_glXCreateContextWithConfigSGIX
+GLAD_API_CALL PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX;
+#define glXCreateGLXPbufferSGIX glad_glXCreateGLXPbufferSGIX
+GLAD_API_CALL PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
+#define glXCreateGLXPixmap glad_glXCreateGLXPixmap
+GLAD_API_CALL PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA;
+#define glXCreateGLXPixmapMESA glad_glXCreateGLXPixmapMESA
+GLAD_API_CALL PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX;
+#define glXCreateGLXPixmapWithConfigSGIX glad_glXCreateGLXPixmapWithConfigSGIX
+GLAD_API_CALL PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
+#define glXCreateNewContext glad_glXCreateNewContext
+GLAD_API_CALL PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
+#define glXCreatePbuffer glad_glXCreatePbuffer
+GLAD_API_CALL PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
+#define glXCreatePixmap glad_glXCreatePixmap
+GLAD_API_CALL PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
+#define glXCreateWindow glad_glXCreateWindow
+GLAD_API_CALL PFNGLXCUSHIONSGIPROC glad_glXCushionSGI;
+#define glXCushionSGI glad_glXCushionSGI
+GLAD_API_CALL PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
+#define glXDelayBeforeSwapNV glad_glXDelayBeforeSwapNV
+GLAD_API_CALL PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD;
+#define glXDeleteAssociatedContextAMD glad_glXDeleteAssociatedContextAMD
+GLAD_API_CALL PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
+#define glXDestroyContext glad_glXDestroyContext
+GLAD_API_CALL PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX;
+#define glXDestroyGLXPbufferSGIX glad_glXDestroyGLXPbufferSGIX
+GLAD_API_CALL PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
+#define glXDestroyGLXPixmap glad_glXDestroyGLXPixmap
+GLAD_API_CALL PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX;
+#define glXDestroyHyperpipeConfigSGIX glad_glXDestroyHyperpipeConfigSGIX
+GLAD_API_CALL PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
+#define glXDestroyPbuffer glad_glXDestroyPbuffer
+GLAD_API_CALL PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
+#define glXDestroyPixmap glad_glXDestroyPixmap
+GLAD_API_CALL PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
+#define glXDestroyWindow glad_glXDestroyWindow
+GLAD_API_CALL PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV;
+#define glXEnumerateVideoCaptureDevicesNV glad_glXEnumerateVideoCaptureDevicesNV
+GLAD_API_CALL PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV;
+#define glXEnumerateVideoDevicesNV glad_glXEnumerateVideoDevicesNV
+GLAD_API_CALL PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT;
+#define glXFreeContextEXT glad_glXFreeContextEXT
+GLAD_API_CALL PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA;
+#define glXGetAGPOffsetMESA glad_glXGetAGPOffsetMESA
+GLAD_API_CALL PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
+#define glXGetClientString glad_glXGetClientString
+GLAD_API_CALL PFNGLXGETCONFIGPROC glad_glXGetConfig;
+#define glXGetConfig glad_glXGetConfig
+GLAD_API_CALL PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD;
+#define glXGetContextGPUIDAMD glad_glXGetContextGPUIDAMD
+GLAD_API_CALL PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT;
+#define glXGetContextIDEXT glad_glXGetContextIDEXT
+GLAD_API_CALL PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD;
+#define glXGetCurrentAssociatedContextAMD glad_glXGetCurrentAssociatedContextAMD
+GLAD_API_CALL PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
+#define glXGetCurrentContext glad_glXGetCurrentContext
+GLAD_API_CALL PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
+#define glXGetCurrentDisplay glad_glXGetCurrentDisplay
+GLAD_API_CALL PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT;
+#define glXGetCurrentDisplayEXT glad_glXGetCurrentDisplayEXT
+GLAD_API_CALL PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
+#define glXGetCurrentDrawable glad_glXGetCurrentDrawable
+GLAD_API_CALL PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
+#define glXGetCurrentReadDrawable glad_glXGetCurrentReadDrawable
+GLAD_API_CALL PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI;
+#define glXGetCurrentReadDrawableSGI glad_glXGetCurrentReadDrawableSGI
+GLAD_API_CALL PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
+#define glXGetFBConfigAttrib glad_glXGetFBConfigAttrib
+GLAD_API_CALL PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX;
+#define glXGetFBConfigAttribSGIX glad_glXGetFBConfigAttribSGIX
+GLAD_API_CALL PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX;
+#define glXGetFBConfigFromVisualSGIX glad_glXGetFBConfigFromVisualSGIX
+GLAD_API_CALL PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
+#define glXGetFBConfigs glad_glXGetFBConfigs
+GLAD_API_CALL PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD;
+#define glXGetGPUIDsAMD glad_glXGetGPUIDsAMD
+GLAD_API_CALL PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD;
+#define glXGetGPUInfoAMD glad_glXGetGPUInfoAMD
+GLAD_API_CALL PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML;
+#define glXGetMscRateOML glad_glXGetMscRateOML
+GLAD_API_CALL PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
+#define glXGetProcAddress glad_glXGetProcAddress
+GLAD_API_CALL PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB;
+#define glXGetProcAddressARB glad_glXGetProcAddressARB
+GLAD_API_CALL PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
+#define glXGetSelectedEvent glad_glXGetSelectedEvent
+GLAD_API_CALL PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX;
+#define glXGetSelectedEventSGIX glad_glXGetSelectedEventSGIX
+GLAD_API_CALL PFNGLXGETSWAPINTERVALMESAPROC glad_glXGetSwapIntervalMESA;
+#define glXGetSwapIntervalMESA glad_glXGetSwapIntervalMESA
+GLAD_API_CALL PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML;
+#define glXGetSyncValuesOML glad_glXGetSyncValuesOML
+GLAD_API_CALL PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN;
+#define glXGetTransparentIndexSUN glad_glXGetTransparentIndexSUN
+GLAD_API_CALL PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV;
+#define glXGetVideoDeviceNV glad_glXGetVideoDeviceNV
+GLAD_API_CALL PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV;
+#define glXGetVideoInfoNV glad_glXGetVideoInfoNV
+GLAD_API_CALL PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI;
+#define glXGetVideoSyncSGI glad_glXGetVideoSyncSGI
+GLAD_API_CALL PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
+#define glXGetVisualFromFBConfig glad_glXGetVisualFromFBConfig
+GLAD_API_CALL PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX;
+#define glXGetVisualFromFBConfigSGIX glad_glXGetVisualFromFBConfigSGIX
+GLAD_API_CALL PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX;
+#define glXHyperpipeAttribSGIX glad_glXHyperpipeAttribSGIX
+GLAD_API_CALL PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX;
+#define glXHyperpipeConfigSGIX glad_glXHyperpipeConfigSGIX
+GLAD_API_CALL PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT;
+#define glXImportContextEXT glad_glXImportContextEXT
+GLAD_API_CALL PFNGLXISDIRECTPROC glad_glXIsDirect;
+#define glXIsDirect glad_glXIsDirect
+GLAD_API_CALL PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV;
+#define glXJoinSwapGroupNV glad_glXJoinSwapGroupNV
+GLAD_API_CALL PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX;
+#define glXJoinSwapGroupSGIX glad_glXJoinSwapGroupSGIX
+GLAD_API_CALL PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV;
+#define glXLockVideoCaptureDeviceNV glad_glXLockVideoCaptureDeviceNV
+GLAD_API_CALL PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD;
+#define glXMakeAssociatedContextCurrentAMD glad_glXMakeAssociatedContextCurrentAMD
+GLAD_API_CALL PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
+#define glXMakeContextCurrent glad_glXMakeContextCurrent
+GLAD_API_CALL PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
+#define glXMakeCurrent glad_glXMakeCurrent
+GLAD_API_CALL PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI;
+#define glXMakeCurrentReadSGI glad_glXMakeCurrentReadSGI
+GLAD_API_CALL PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV;
+#define glXNamedCopyBufferSubDataNV glad_glXNamedCopyBufferSubDataNV
+GLAD_API_CALL PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX;
+#define glXQueryChannelDeltasSGIX glad_glXQueryChannelDeltasSGIX
+GLAD_API_CALL PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX;
+#define glXQueryChannelRectSGIX glad_glXQueryChannelRectSGIX
+GLAD_API_CALL PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
+#define glXQueryContext glad_glXQueryContext
+GLAD_API_CALL PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT;
+#define glXQueryContextInfoEXT glad_glXQueryContextInfoEXT
+GLAD_API_CALL PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA;
+#define glXQueryCurrentRendererIntegerMESA glad_glXQueryCurrentRendererIntegerMESA
+GLAD_API_CALL PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA;
+#define glXQueryCurrentRendererStringMESA glad_glXQueryCurrentRendererStringMESA
+GLAD_API_CALL PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
+#define glXQueryDrawable glad_glXQueryDrawable
+GLAD_API_CALL PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
+#define glXQueryExtension glad_glXQueryExtension
+GLAD_API_CALL PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
+#define glXQueryExtensionsString glad_glXQueryExtensionsString
+GLAD_API_CALL PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV;
+#define glXQueryFrameCountNV glad_glXQueryFrameCountNV
+GLAD_API_CALL PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX;
+#define glXQueryGLXPbufferSGIX glad_glXQueryGLXPbufferSGIX
+GLAD_API_CALL PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX;
+#define glXQueryHyperpipeAttribSGIX glad_glXQueryHyperpipeAttribSGIX
+GLAD_API_CALL PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX;
+#define glXQueryHyperpipeBestAttribSGIX glad_glXQueryHyperpipeBestAttribSGIX
+GLAD_API_CALL PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX;
+#define glXQueryHyperpipeConfigSGIX glad_glXQueryHyperpipeConfigSGIX
+GLAD_API_CALL PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX;
+#define glXQueryHyperpipeNetworkSGIX glad_glXQueryHyperpipeNetworkSGIX
+GLAD_API_CALL PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX;
+#define glXQueryMaxSwapBarriersSGIX glad_glXQueryMaxSwapBarriersSGIX
+GLAD_API_CALL PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV;
+#define glXQueryMaxSwapGroupsNV glad_glXQueryMaxSwapGroupsNV
+GLAD_API_CALL PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA;
+#define glXQueryRendererIntegerMESA glad_glXQueryRendererIntegerMESA
+GLAD_API_CALL PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA;
+#define glXQueryRendererStringMESA glad_glXQueryRendererStringMESA
+GLAD_API_CALL PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
+#define glXQueryServerString glad_glXQueryServerString
+GLAD_API_CALL PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV;
+#define glXQuerySwapGroupNV glad_glXQuerySwapGroupNV
+GLAD_API_CALL PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
+#define glXQueryVersion glad_glXQueryVersion
+GLAD_API_CALL PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV;
+#define glXQueryVideoCaptureDeviceNV glad_glXQueryVideoCaptureDeviceNV
+GLAD_API_CALL PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA;
+#define glXReleaseBuffersMESA glad_glXReleaseBuffersMESA
+GLAD_API_CALL PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT;
+#define glXReleaseTexImageEXT glad_glXReleaseTexImageEXT
+GLAD_API_CALL PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV;
+#define glXReleaseVideoCaptureDeviceNV glad_glXReleaseVideoCaptureDeviceNV
+GLAD_API_CALL PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV;
+#define glXReleaseVideoDeviceNV glad_glXReleaseVideoDeviceNV
+GLAD_API_CALL PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV;
+#define glXReleaseVideoImageNV glad_glXReleaseVideoImageNV
+GLAD_API_CALL PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV;
+#define glXResetFrameCountNV glad_glXResetFrameCountNV
+GLAD_API_CALL PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
+#define glXSelectEvent glad_glXSelectEvent
+GLAD_API_CALL PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX;
+#define glXSelectEventSGIX glad_glXSelectEventSGIX
+GLAD_API_CALL PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV;
+#define glXSendPbufferToVideoNV glad_glXSendPbufferToVideoNV
+GLAD_API_CALL PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA;
+#define glXSet3DfxModeMESA glad_glXSet3DfxModeMESA
+GLAD_API_CALL PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
+#define glXSwapBuffers glad_glXSwapBuffers
+GLAD_API_CALL PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML;
+#define glXSwapBuffersMscOML glad_glXSwapBuffersMscOML
+GLAD_API_CALL PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT;
+#define glXSwapIntervalEXT glad_glXSwapIntervalEXT
+GLAD_API_CALL PFNGLXSWAPINTERVALMESAPROC glad_glXSwapIntervalMESA;
+#define glXSwapIntervalMESA glad_glXSwapIntervalMESA
+GLAD_API_CALL PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI;
+#define glXSwapIntervalSGI glad_glXSwapIntervalSGI
+GLAD_API_CALL PFNGLXUSEXFONTPROC glad_glXUseXFont;
+#define glXUseXFont glad_glXUseXFont
+GLAD_API_CALL PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML;
+#define glXWaitForMscOML glad_glXWaitForMscOML
+GLAD_API_CALL PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML;
+#define glXWaitForSbcOML glad_glXWaitForSbcOML
+GLAD_API_CALL PFNGLXWAITGLPROC glad_glXWaitGL;
+#define glXWaitGL glad_glXWaitGL
+GLAD_API_CALL PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI;
+#define glXWaitVideoSyncSGI glad_glXWaitVideoSyncSGI
+GLAD_API_CALL PFNGLXWAITXPROC glad_glXWaitX;
+#define glXWaitX glad_glXWaitX
+
+
+GLAD_API_CALL int gladLoadGLXUserPtr(Display *display, int screen, GLADuserptrloadfunc load, void *userptr);
+GLAD_API_CALL int gladLoadGLX(Display *display, int screen, GLADloadfunc load);
+
+
+
+
+#ifdef GLAD_GLX
+
+GLAD_API_CALL int gladLoaderLoadGLX(Display *display, int screen);
+
+GLAD_API_CALL void gladLoaderUnloadGLX(void);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+/* Source */
+#ifdef GLAD_GLX_IMPLEMENTATION
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+
+int GLAD_GLX_VERSION_1_0 = 0;
+int GLAD_GLX_VERSION_1_1 = 0;
+int GLAD_GLX_VERSION_1_2 = 0;
+int GLAD_GLX_VERSION_1_3 = 0;
+int GLAD_GLX_VERSION_1_4 = 0;
+int GLAD_GLX_3DFX_multisample = 0;
+int GLAD_GLX_AMD_gpu_association = 0;
+int GLAD_GLX_ARB_context_flush_control = 0;
+int GLAD_GLX_ARB_create_context = 0;
+int GLAD_GLX_ARB_create_context_no_error = 0;
+int GLAD_GLX_ARB_create_context_profile = 0;
+int GLAD_GLX_ARB_create_context_robustness = 0;
+int GLAD_GLX_ARB_fbconfig_float = 0;
+int GLAD_GLX_ARB_framebuffer_sRGB = 0;
+int GLAD_GLX_ARB_get_proc_address = 0;
+int GLAD_GLX_ARB_multisample = 0;
+int GLAD_GLX_ARB_robustness_application_isolation = 0;
+int GLAD_GLX_ARB_robustness_share_group_isolation = 0;
+int GLAD_GLX_ARB_vertex_buffer_object = 0;
+int GLAD_GLX_EXT_buffer_age = 0;
+int GLAD_GLX_EXT_create_context_es2_profile = 0;
+int GLAD_GLX_EXT_create_context_es_profile = 0;
+int GLAD_GLX_EXT_fbconfig_packed_float = 0;
+int GLAD_GLX_EXT_framebuffer_sRGB = 0;
+int GLAD_GLX_EXT_import_context = 0;
+int GLAD_GLX_EXT_libglvnd = 0;
+int GLAD_GLX_EXT_no_config_context = 0;
+int GLAD_GLX_EXT_stereo_tree = 0;
+int GLAD_GLX_EXT_swap_control = 0;
+int GLAD_GLX_EXT_swap_control_tear = 0;
+int GLAD_GLX_EXT_texture_from_pixmap = 0;
+int GLAD_GLX_EXT_visual_info = 0;
+int GLAD_GLX_EXT_visual_rating = 0;
+int GLAD_GLX_INTEL_swap_event = 0;
+int GLAD_GLX_MESA_agp_offset = 0;
+int GLAD_GLX_MESA_copy_sub_buffer = 0;
+int GLAD_GLX_MESA_pixmap_colormap = 0;
+int GLAD_GLX_MESA_query_renderer = 0;
+int GLAD_GLX_MESA_release_buffers = 0;
+int GLAD_GLX_MESA_set_3dfx_mode = 0;
+int GLAD_GLX_MESA_swap_control = 0;
+int GLAD_GLX_NV_copy_buffer = 0;
+int GLAD_GLX_NV_copy_image = 0;
+int GLAD_GLX_NV_delay_before_swap = 0;
+int GLAD_GLX_NV_float_buffer = 0;
+int GLAD_GLX_NV_multisample_coverage = 0;
+int GLAD_GLX_NV_present_video = 0;
+int GLAD_GLX_NV_robustness_video_memory_purge = 0;
+int GLAD_GLX_NV_swap_group = 0;
+int GLAD_GLX_NV_video_capture = 0;
+int GLAD_GLX_NV_video_out = 0;
+int GLAD_GLX_OML_swap_method = 0;
+int GLAD_GLX_OML_sync_control = 0;
+int GLAD_GLX_SGIS_blended_overlay = 0;
+int GLAD_GLX_SGIS_multisample = 0;
+int GLAD_GLX_SGIS_shared_multisample = 0;
+int GLAD_GLX_SGIX_fbconfig = 0;
+int GLAD_GLX_SGIX_hyperpipe = 0;
+int GLAD_GLX_SGIX_pbuffer = 0;
+int GLAD_GLX_SGIX_swap_barrier = 0;
+int GLAD_GLX_SGIX_swap_group = 0;
+int GLAD_GLX_SGIX_video_resize = 0;
+int GLAD_GLX_SGIX_visual_select_group = 0;
+int GLAD_GLX_SGI_cushion = 0;
+int GLAD_GLX_SGI_make_current_read = 0;
+int GLAD_GLX_SGI_swap_control = 0;
+int GLAD_GLX_SGI_video_sync = 0;
+int GLAD_GLX_SUN_get_transparent_index = 0;
+
+
+
+PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX = NULL;
+PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX = NULL;
+PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV = NULL;
+PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX = NULL;
+PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT = NULL;
+PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV = NULL;
+PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV = NULL;
+PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV = NULL;
+PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD = NULL;
+PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX = NULL;
+PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX = NULL;
+PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig = NULL;
+PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX = NULL;
+PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual = NULL;
+PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV = NULL;
+PFNGLXCOPYCONTEXTPROC glad_glXCopyContext = NULL;
+PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV = NULL;
+PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA = NULL;
+PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD = NULL;
+PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD = NULL;
+PFNGLXCREATECONTEXTPROC glad_glXCreateContext = NULL;
+PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB = NULL;
+PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX = NULL;
+PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX = NULL;
+PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap = NULL;
+PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA = NULL;
+PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX = NULL;
+PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext = NULL;
+PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer = NULL;
+PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap = NULL;
+PFNGLXCREATEWINDOWPROC glad_glXCreateWindow = NULL;
+PFNGLXCUSHIONSGIPROC glad_glXCushionSGI = NULL;
+PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV = NULL;
+PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD = NULL;
+PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext = NULL;
+PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX = NULL;
+PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap = NULL;
+PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX = NULL;
+PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer = NULL;
+PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap = NULL;
+PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow = NULL;
+PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV = NULL;
+PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV = NULL;
+PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT = NULL;
+PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA = NULL;
+PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString = NULL;
+PFNGLXGETCONFIGPROC glad_glXGetConfig = NULL;
+PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD = NULL;
+PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT = NULL;
+PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD = NULL;
+PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext = NULL;
+PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay = NULL;
+PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT = NULL;
+PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable = NULL;
+PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable = NULL;
+PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI = NULL;
+PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib = NULL;
+PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX = NULL;
+PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX = NULL;
+PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs = NULL;
+PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD = NULL;
+PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD = NULL;
+PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML = NULL;
+PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress = NULL;
+PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB = NULL;
+PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent = NULL;
+PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX = NULL;
+PFNGLXGETSWAPINTERVALMESAPROC glad_glXGetSwapIntervalMESA = NULL;
+PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML = NULL;
+PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN = NULL;
+PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV = NULL;
+PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV = NULL;
+PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI = NULL;
+PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig = NULL;
+PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX = NULL;
+PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX = NULL;
+PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX = NULL;
+PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT = NULL;
+PFNGLXISDIRECTPROC glad_glXIsDirect = NULL;
+PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV = NULL;
+PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX = NULL;
+PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV = NULL;
+PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD = NULL;
+PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent = NULL;
+PFNGLXMAKECURRENTPROC glad_glXMakeCurrent = NULL;
+PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI = NULL;
+PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV = NULL;
+PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX = NULL;
+PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX = NULL;
+PFNGLXQUERYCONTEXTPROC glad_glXQueryContext = NULL;
+PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT = NULL;
+PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA = NULL;
+PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA = NULL;
+PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable = NULL;
+PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension = NULL;
+PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString = NULL;
+PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV = NULL;
+PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX = NULL;
+PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX = NULL;
+PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX = NULL;
+PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX = NULL;
+PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX = NULL;
+PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX = NULL;
+PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV = NULL;
+PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA = NULL;
+PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA = NULL;
+PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString = NULL;
+PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV = NULL;
+PFNGLXQUERYVERSIONPROC glad_glXQueryVersion = NULL;
+PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV = NULL;
+PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA = NULL;
+PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT = NULL;
+PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV = NULL;
+PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV = NULL;
+PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV = NULL;
+PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV = NULL;
+PFNGLXSELECTEVENTPROC glad_glXSelectEvent = NULL;
+PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX = NULL;
+PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV = NULL;
+PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA = NULL;
+PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers = NULL;
+PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML = NULL;
+PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT = NULL;
+PFNGLXSWAPINTERVALMESAPROC glad_glXSwapIntervalMESA = NULL;
+PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI = NULL;
+PFNGLXUSEXFONTPROC glad_glXUseXFont = NULL;
+PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML = NULL;
+PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML = NULL;
+PFNGLXWAITGLPROC glad_glXWaitGL = NULL;
+PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI = NULL;
+PFNGLXWAITXPROC glad_glXWaitX = NULL;
+
+
+static void glad_glx_load_GLX_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_VERSION_1_0) return;
+    glXChooseVisual = (PFNGLXCHOOSEVISUALPROC) load("glXChooseVisual", userptr);
+    glXCopyContext = (PFNGLXCOPYCONTEXTPROC) load("glXCopyContext", userptr);
+    glXCreateContext = (PFNGLXCREATECONTEXTPROC) load("glXCreateContext", userptr);
+    glXCreateGLXPixmap = (PFNGLXCREATEGLXPIXMAPPROC) load("glXCreateGLXPixmap", userptr);
+    glXDestroyContext = (PFNGLXDESTROYCONTEXTPROC) load("glXDestroyContext", userptr);
+    glXDestroyGLXPixmap = (PFNGLXDESTROYGLXPIXMAPPROC) load("glXDestroyGLXPixmap", userptr);
+    glXGetConfig = (PFNGLXGETCONFIGPROC) load("glXGetConfig", userptr);
+    glXGetCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) load("glXGetCurrentContext", userptr);
+    glXGetCurrentDrawable = (PFNGLXGETCURRENTDRAWABLEPROC) load("glXGetCurrentDrawable", userptr);
+    glXIsDirect = (PFNGLXISDIRECTPROC) load("glXIsDirect", userptr);
+    glXMakeCurrent = (PFNGLXMAKECURRENTPROC) load("glXMakeCurrent", userptr);
+    glXQueryExtension = (PFNGLXQUERYEXTENSIONPROC) load("glXQueryExtension", userptr);
+    glXQueryVersion = (PFNGLXQUERYVERSIONPROC) load("glXQueryVersion", userptr);
+    glXSwapBuffers = (PFNGLXSWAPBUFFERSPROC) load("glXSwapBuffers", userptr);
+    glXUseXFont = (PFNGLXUSEXFONTPROC) load("glXUseXFont", userptr);
+    glXWaitGL = (PFNGLXWAITGLPROC) load("glXWaitGL", userptr);
+    glXWaitX = (PFNGLXWAITXPROC) load("glXWaitX", userptr);
+}
+static void glad_glx_load_GLX_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_VERSION_1_1) return;
+    glXGetClientString = (PFNGLXGETCLIENTSTRINGPROC) load("glXGetClientString", userptr);
+    glXQueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC) load("glXQueryExtensionsString", userptr);
+    glXQueryServerString = (PFNGLXQUERYSERVERSTRINGPROC) load("glXQueryServerString", userptr);
+}
+static void glad_glx_load_GLX_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_VERSION_1_2) return;
+    glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC) load("glXGetCurrentDisplay", userptr);
+}
+static void glad_glx_load_GLX_VERSION_1_3( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_VERSION_1_3) return;
+    glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) load("glXChooseFBConfig", userptr);
+    glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC) load("glXCreateNewContext", userptr);
+    glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC) load("glXCreatePbuffer", userptr);
+    glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC) load("glXCreatePixmap", userptr);
+    glXCreateWindow = (PFNGLXCREATEWINDOWPROC) load("glXCreateWindow", userptr);
+    glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) load("glXDestroyPbuffer", userptr);
+    glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC) load("glXDestroyPixmap", userptr);
+    glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC) load("glXDestroyWindow", userptr);
+    glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC) load("glXGetCurrentReadDrawable", userptr);
+    glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC) load("glXGetFBConfigAttrib", userptr);
+    glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC) load("glXGetFBConfigs", userptr);
+    glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC) load("glXGetSelectedEvent", userptr);
+    glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC) load("glXGetVisualFromFBConfig", userptr);
+    glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC) load("glXMakeContextCurrent", userptr);
+    glXQueryContext = (PFNGLXQUERYCONTEXTPROC) load("glXQueryContext", userptr);
+    glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC) load("glXQueryDrawable", userptr);
+    glXSelectEvent = (PFNGLXSELECTEVENTPROC) load("glXSelectEvent", userptr);
+}
+static void glad_glx_load_GLX_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_VERSION_1_4) return;
+    glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC) load("glXGetProcAddress", userptr);
+}
+static void glad_glx_load_GLX_AMD_gpu_association( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_AMD_gpu_association) return;
+    glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC) load("glXBlitContextFramebufferAMD", userptr);
+    glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC) load("glXCreateAssociatedContextAMD", userptr);
+    glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) load("glXCreateAssociatedContextAttribsAMD", userptr);
+    glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC) load("glXDeleteAssociatedContextAMD", userptr);
+    glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC) load("glXGetContextGPUIDAMD", userptr);
+    glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC) load("glXGetCurrentAssociatedContextAMD", userptr);
+    glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC) load("glXGetGPUIDsAMD", userptr);
+    glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC) load("glXGetGPUInfoAMD", userptr);
+    glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) load("glXMakeAssociatedContextCurrentAMD", userptr);
+}
+static void glad_glx_load_GLX_ARB_create_context( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_ARB_create_context) return;
+    glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) load("glXCreateContextAttribsARB", userptr);
+}
+static void glad_glx_load_GLX_ARB_get_proc_address( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_ARB_get_proc_address) return;
+    glXGetProcAddressARB = (PFNGLXGETPROCADDRESSARBPROC) load("glXGetProcAddressARB", userptr);
+}
+static void glad_glx_load_GLX_EXT_import_context( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_EXT_import_context) return;
+    glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC) load("glXFreeContextEXT", userptr);
+    glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC) load("glXGetContextIDEXT", userptr);
+    glXGetCurrentDisplayEXT = (PFNGLXGETCURRENTDISPLAYEXTPROC) load("glXGetCurrentDisplayEXT", userptr);
+    glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC) load("glXImportContextEXT", userptr);
+    glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC) load("glXQueryContextInfoEXT", userptr);
+}
+static void glad_glx_load_GLX_EXT_swap_control( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_EXT_swap_control) return;
+    glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) load("glXSwapIntervalEXT", userptr);
+}
+static void glad_glx_load_GLX_EXT_texture_from_pixmap( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_EXT_texture_from_pixmap) return;
+    glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC) load("glXBindTexImageEXT", userptr);
+    glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC) load("glXReleaseTexImageEXT", userptr);
+}
+static void glad_glx_load_GLX_MESA_agp_offset( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_agp_offset) return;
+    glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC) load("glXGetAGPOffsetMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_copy_sub_buffer( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_copy_sub_buffer) return;
+    glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC) load("glXCopySubBufferMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_pixmap_colormap( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_pixmap_colormap) return;
+    glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC) load("glXCreateGLXPixmapMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_query_renderer( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_query_renderer) return;
+    glXQueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC) load("glXQueryCurrentRendererIntegerMESA", userptr);
+    glXQueryCurrentRendererStringMESA = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC) load("glXQueryCurrentRendererStringMESA", userptr);
+    glXQueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESAPROC) load("glXQueryRendererIntegerMESA", userptr);
+    glXQueryRendererStringMESA = (PFNGLXQUERYRENDERERSTRINGMESAPROC) load("glXQueryRendererStringMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_release_buffers( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_release_buffers) return;
+    glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC) load("glXReleaseBuffersMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_set_3dfx_mode( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_set_3dfx_mode) return;
+    glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC) load("glXSet3DfxModeMESA", userptr);
+}
+static void glad_glx_load_GLX_MESA_swap_control( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_MESA_swap_control) return;
+    glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC) load("glXGetSwapIntervalMESA", userptr);
+    glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC) load("glXSwapIntervalMESA", userptr);
+}
+static void glad_glx_load_GLX_NV_copy_buffer( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_copy_buffer) return;
+    glXCopyBufferSubDataNV = (PFNGLXCOPYBUFFERSUBDATANVPROC) load("glXCopyBufferSubDataNV", userptr);
+    glXNamedCopyBufferSubDataNV = (PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC) load("glXNamedCopyBufferSubDataNV", userptr);
+}
+static void glad_glx_load_GLX_NV_copy_image( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_copy_image) return;
+    glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC) load("glXCopyImageSubDataNV", userptr);
+}
+static void glad_glx_load_GLX_NV_delay_before_swap( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_delay_before_swap) return;
+    glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC) load("glXDelayBeforeSwapNV", userptr);
+}
+static void glad_glx_load_GLX_NV_present_video( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_present_video) return;
+    glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC) load("glXBindVideoDeviceNV", userptr);
+    glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC) load("glXEnumerateVideoDevicesNV", userptr);
+}
+static void glad_glx_load_GLX_NV_swap_group( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_swap_group) return;
+    glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC) load("glXBindSwapBarrierNV", userptr);
+    glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC) load("glXJoinSwapGroupNV", userptr);
+    glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC) load("glXQueryFrameCountNV", userptr);
+    glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC) load("glXQueryMaxSwapGroupsNV", userptr);
+    glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC) load("glXQuerySwapGroupNV", userptr);
+    glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC) load("glXResetFrameCountNV", userptr);
+}
+static void glad_glx_load_GLX_NV_video_capture( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_video_capture) return;
+    glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) load("glXBindVideoCaptureDeviceNV", userptr);
+    glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) load("glXEnumerateVideoCaptureDevicesNV", userptr);
+    glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) load("glXLockVideoCaptureDeviceNV", userptr);
+    glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) load("glXQueryVideoCaptureDeviceNV", userptr);
+    glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) load("glXReleaseVideoCaptureDeviceNV", userptr);
+}
+static void glad_glx_load_GLX_NV_video_out( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_NV_video_out) return;
+    glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC) load("glXBindVideoImageNV", userptr);
+    glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC) load("glXGetVideoDeviceNV", userptr);
+    glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC) load("glXGetVideoInfoNV", userptr);
+    glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC) load("glXReleaseVideoDeviceNV", userptr);
+    glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC) load("glXReleaseVideoImageNV", userptr);
+    glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC) load("glXSendPbufferToVideoNV", userptr);
+}
+static void glad_glx_load_GLX_OML_sync_control( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_OML_sync_control) return;
+    glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC) load("glXGetMscRateOML", userptr);
+    glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC) load("glXGetSyncValuesOML", userptr);
+    glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC) load("glXSwapBuffersMscOML", userptr);
+    glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC) load("glXWaitForMscOML", userptr);
+    glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC) load("glXWaitForSbcOML", userptr);
+}
+static void glad_glx_load_GLX_SGIX_fbconfig( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_fbconfig) return;
+    glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC) load("glXChooseFBConfigSGIX", userptr);
+    glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) load("glXCreateContextWithConfigSGIX", userptr);
+    glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) load("glXCreateGLXPixmapWithConfigSGIX", userptr);
+    glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC) load("glXGetFBConfigAttribSGIX", userptr);
+    glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) load("glXGetFBConfigFromVisualSGIX", userptr);
+    glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) load("glXGetVisualFromFBConfigSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGIX_hyperpipe( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_hyperpipe) return;
+    glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC) load("glXBindHyperpipeSGIX", userptr);
+    glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) load("glXDestroyHyperpipeConfigSGIX", userptr);
+    glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC) load("glXHyperpipeAttribSGIX", userptr);
+    glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC) load("glXHyperpipeConfigSGIX", userptr);
+    glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) load("glXQueryHyperpipeAttribSGIX", userptr);
+    glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) load("glXQueryHyperpipeBestAttribSGIX", userptr);
+    glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) load("glXQueryHyperpipeConfigSGIX", userptr);
+    glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) load("glXQueryHyperpipeNetworkSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGIX_pbuffer( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_pbuffer) return;
+    glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC) load("glXCreateGLXPbufferSGIX", userptr);
+    glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC) load("glXDestroyGLXPbufferSGIX", userptr);
+    glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC) load("glXGetSelectedEventSGIX", userptr);
+    glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC) load("glXQueryGLXPbufferSGIX", userptr);
+    glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC) load("glXSelectEventSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGIX_swap_barrier( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_swap_barrier) return;
+    glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC) load("glXBindSwapBarrierSGIX", userptr);
+    glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) load("glXQueryMaxSwapBarriersSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGIX_swap_group( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_swap_group) return;
+    glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC) load("glXJoinSwapGroupSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGIX_video_resize( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGIX_video_resize) return;
+    glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC) load("glXBindChannelToWindowSGIX", userptr);
+    glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC) load("glXChannelRectSGIX", userptr);
+    glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC) load("glXChannelRectSyncSGIX", userptr);
+    glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC) load("glXQueryChannelDeltasSGIX", userptr);
+    glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC) load("glXQueryChannelRectSGIX", userptr);
+}
+static void glad_glx_load_GLX_SGI_cushion( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGI_cushion) return;
+    glXCushionSGI = (PFNGLXCUSHIONSGIPROC) load("glXCushionSGI", userptr);
+}
+static void glad_glx_load_GLX_SGI_make_current_read( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGI_make_current_read) return;
+    glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC) load("glXGetCurrentReadDrawableSGI", userptr);
+    glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC) load("glXMakeCurrentReadSGI", userptr);
+}
+static void glad_glx_load_GLX_SGI_swap_control( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGI_swap_control) return;
+    glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) load("glXSwapIntervalSGI", userptr);
+}
+static void glad_glx_load_GLX_SGI_video_sync( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SGI_video_sync) return;
+    glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC) load("glXGetVideoSyncSGI", userptr);
+    glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC) load("glXWaitVideoSyncSGI", userptr);
+}
+static void glad_glx_load_GLX_SUN_get_transparent_index( GLADuserptrloadfunc load, void* userptr) {
+    if(!GLAD_GLX_SUN_get_transparent_index) return;
+    glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC) load("glXGetTransparentIndexSUN", userptr);
+}
+
+
+
+static int glad_glx_has_extension(Display *display, int screen, const char *ext) {
+#ifndef GLX_VERSION_1_1
+    (void) display;
+    (void) screen;
+    (void) ext;
+#else
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if (glXQueryExtensionsString == NULL) {
+        return 0;
+    }
+
+    extensions = glXQueryExtensionsString(display, screen);
+
+    if(extensions == NULL || ext == NULL) {
+        return 0;
+    }
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\0')) {
+            return 1;
+        }
+        extensions = terminator;
+    }
+#endif
+
+    return 0;
+}
+
+static GLADapiproc glad_glx_get_proc_from_userptr(const char* name, void *userptr) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_glx_find_extensions(Display *display, int screen) {
+    GLAD_GLX_3DFX_multisample = glad_glx_has_extension(display, screen, "GLX_3DFX_multisample");
+    GLAD_GLX_AMD_gpu_association = glad_glx_has_extension(display, screen, "GLX_AMD_gpu_association");
+    GLAD_GLX_ARB_context_flush_control = glad_glx_has_extension(display, screen, "GLX_ARB_context_flush_control");
+    GLAD_GLX_ARB_create_context = glad_glx_has_extension(display, screen, "GLX_ARB_create_context");
+    GLAD_GLX_ARB_create_context_no_error = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_no_error");
+    GLAD_GLX_ARB_create_context_profile = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_profile");
+    GLAD_GLX_ARB_create_context_robustness = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_robustness");
+    GLAD_GLX_ARB_fbconfig_float = glad_glx_has_extension(display, screen, "GLX_ARB_fbconfig_float");
+    GLAD_GLX_ARB_framebuffer_sRGB = glad_glx_has_extension(display, screen, "GLX_ARB_framebuffer_sRGB");
+    GLAD_GLX_ARB_get_proc_address = glad_glx_has_extension(display, screen, "GLX_ARB_get_proc_address");
+    GLAD_GLX_ARB_multisample = glad_glx_has_extension(display, screen, "GLX_ARB_multisample");
+    GLAD_GLX_ARB_robustness_application_isolation = glad_glx_has_extension(display, screen, "GLX_ARB_robustness_application_isolation");
+    GLAD_GLX_ARB_robustness_share_group_isolation = glad_glx_has_extension(display, screen, "GLX_ARB_robustness_share_group_isolation");
+    GLAD_GLX_ARB_vertex_buffer_object = glad_glx_has_extension(display, screen, "GLX_ARB_vertex_buffer_object");
+    GLAD_GLX_EXT_buffer_age = glad_glx_has_extension(display, screen, "GLX_EXT_buffer_age");
+    GLAD_GLX_EXT_create_context_es2_profile = glad_glx_has_extension(display, screen, "GLX_EXT_create_context_es2_profile");
+    GLAD_GLX_EXT_create_context_es_profile = glad_glx_has_extension(display, screen, "GLX_EXT_create_context_es_profile");
+    GLAD_GLX_EXT_fbconfig_packed_float = glad_glx_has_extension(display, screen, "GLX_EXT_fbconfig_packed_float");
+    GLAD_GLX_EXT_framebuffer_sRGB = glad_glx_has_extension(display, screen, "GLX_EXT_framebuffer_sRGB");
+    GLAD_GLX_EXT_import_context = glad_glx_has_extension(display, screen, "GLX_EXT_import_context");
+    GLAD_GLX_EXT_libglvnd = glad_glx_has_extension(display, screen, "GLX_EXT_libglvnd");
+    GLAD_GLX_EXT_no_config_context = glad_glx_has_extension(display, screen, "GLX_EXT_no_config_context");
+    GLAD_GLX_EXT_stereo_tree = glad_glx_has_extension(display, screen, "GLX_EXT_stereo_tree");
+    GLAD_GLX_EXT_swap_control = glad_glx_has_extension(display, screen, "GLX_EXT_swap_control");
+    GLAD_GLX_EXT_swap_control_tear = glad_glx_has_extension(display, screen, "GLX_EXT_swap_control_tear");
+    GLAD_GLX_EXT_texture_from_pixmap = glad_glx_has_extension(display, screen, "GLX_EXT_texture_from_pixmap");
+    GLAD_GLX_EXT_visual_info = glad_glx_has_extension(display, screen, "GLX_EXT_visual_info");
+    GLAD_GLX_EXT_visual_rating = glad_glx_has_extension(display, screen, "GLX_EXT_visual_rating");
+    GLAD_GLX_INTEL_swap_event = glad_glx_has_extension(display, screen, "GLX_INTEL_swap_event");
+    GLAD_GLX_MESA_agp_offset = glad_glx_has_extension(display, screen, "GLX_MESA_agp_offset");
+    GLAD_GLX_MESA_copy_sub_buffer = glad_glx_has_extension(display, screen, "GLX_MESA_copy_sub_buffer");
+    GLAD_GLX_MESA_pixmap_colormap = glad_glx_has_extension(display, screen, "GLX_MESA_pixmap_colormap");
+    GLAD_GLX_MESA_query_renderer = glad_glx_has_extension(display, screen, "GLX_MESA_query_renderer");
+    GLAD_GLX_MESA_release_buffers = glad_glx_has_extension(display, screen, "GLX_MESA_release_buffers");
+    GLAD_GLX_MESA_set_3dfx_mode = glad_glx_has_extension(display, screen, "GLX_MESA_set_3dfx_mode");
+    GLAD_GLX_MESA_swap_control = glad_glx_has_extension(display, screen, "GLX_MESA_swap_control");
+    GLAD_GLX_NV_copy_buffer = glad_glx_has_extension(display, screen, "GLX_NV_copy_buffer");
+    GLAD_GLX_NV_copy_image = glad_glx_has_extension(display, screen, "GLX_NV_copy_image");
+    GLAD_GLX_NV_delay_before_swap = glad_glx_has_extension(display, screen, "GLX_NV_delay_before_swap");
+    GLAD_GLX_NV_float_buffer = glad_glx_has_extension(display, screen, "GLX_NV_float_buffer");
+    GLAD_GLX_NV_multisample_coverage = glad_glx_has_extension(display, screen, "GLX_NV_multisample_coverage");
+    GLAD_GLX_NV_present_video = glad_glx_has_extension(display, screen, "GLX_NV_present_video");
+    GLAD_GLX_NV_robustness_video_memory_purge = glad_glx_has_extension(display, screen, "GLX_NV_robustness_video_memory_purge");
+    GLAD_GLX_NV_swap_group = glad_glx_has_extension(display, screen, "GLX_NV_swap_group");
+    GLAD_GLX_NV_video_capture = glad_glx_has_extension(display, screen, "GLX_NV_video_capture");
+    GLAD_GLX_NV_video_out = glad_glx_has_extension(display, screen, "GLX_NV_video_out");
+    GLAD_GLX_OML_swap_method = glad_glx_has_extension(display, screen, "GLX_OML_swap_method");
+    GLAD_GLX_OML_sync_control = glad_glx_has_extension(display, screen, "GLX_OML_sync_control");
+    GLAD_GLX_SGIS_blended_overlay = glad_glx_has_extension(display, screen, "GLX_SGIS_blended_overlay");
+    GLAD_GLX_SGIS_multisample = glad_glx_has_extension(display, screen, "GLX_SGIS_multisample");
+    GLAD_GLX_SGIS_shared_multisample = glad_glx_has_extension(display, screen, "GLX_SGIS_shared_multisample");
+    GLAD_GLX_SGIX_fbconfig = glad_glx_has_extension(display, screen, "GLX_SGIX_fbconfig");
+    GLAD_GLX_SGIX_hyperpipe = glad_glx_has_extension(display, screen, "GLX_SGIX_hyperpipe");
+    GLAD_GLX_SGIX_pbuffer = glad_glx_has_extension(display, screen, "GLX_SGIX_pbuffer");
+    GLAD_GLX_SGIX_swap_barrier = glad_glx_has_extension(display, screen, "GLX_SGIX_swap_barrier");
+    GLAD_GLX_SGIX_swap_group = glad_glx_has_extension(display, screen, "GLX_SGIX_swap_group");
+    GLAD_GLX_SGIX_video_resize = glad_glx_has_extension(display, screen, "GLX_SGIX_video_resize");
+    GLAD_GLX_SGIX_visual_select_group = glad_glx_has_extension(display, screen, "GLX_SGIX_visual_select_group");
+    GLAD_GLX_SGI_cushion = glad_glx_has_extension(display, screen, "GLX_SGI_cushion");
+    GLAD_GLX_SGI_make_current_read = glad_glx_has_extension(display, screen, "GLX_SGI_make_current_read");
+    GLAD_GLX_SGI_swap_control = glad_glx_has_extension(display, screen, "GLX_SGI_swap_control");
+    GLAD_GLX_SGI_video_sync = glad_glx_has_extension(display, screen, "GLX_SGI_video_sync");
+    GLAD_GLX_SUN_get_transparent_index = glad_glx_has_extension(display, screen, "GLX_SUN_get_transparent_index");
+    return 1;
+}
+
+static int glad_glx_find_core_glx(Display **display, int *screen) {
+    int major = 0, minor = 0;
+    if(*display == NULL) {
+#ifdef GLAD_GLX_NO_X11
+        (void) screen;
+        return 0;
+#else
+        *display = XOpenDisplay(0);
+        if (*display == NULL) {
+            return 0;
+        }
+        *screen = XScreenNumberOfScreen(XDefaultScreenOfDisplay(*display));
+#endif
+    }
+    glXQueryVersion(*display, &major, &minor);
+    GLAD_GLX_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+    GLAD_GLX_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
+    GLAD_GLX_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
+    GLAD_GLX_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
+    GLAD_GLX_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadGLXUserPtr(Display *display, int screen, GLADuserptrloadfunc load, void *userptr) {
+    int version;
+    glXQueryVersion = (PFNGLXQUERYVERSIONPROC) load("glXQueryVersion", userptr);
+    if(glXQueryVersion == NULL) return 0;
+    version = glad_glx_find_core_glx(&display, &screen);
+
+    glad_glx_load_GLX_VERSION_1_0(load, userptr);
+    glad_glx_load_GLX_VERSION_1_1(load, userptr);
+    glad_glx_load_GLX_VERSION_1_2(load, userptr);
+    glad_glx_load_GLX_VERSION_1_3(load, userptr);
+    glad_glx_load_GLX_VERSION_1_4(load, userptr);
+
+    if (!glad_glx_find_extensions(display, screen)) return 0;
+    glad_glx_load_GLX_AMD_gpu_association(load, userptr);
+    glad_glx_load_GLX_ARB_create_context(load, userptr);
+    glad_glx_load_GLX_ARB_get_proc_address(load, userptr);
+    glad_glx_load_GLX_EXT_import_context(load, userptr);
+    glad_glx_load_GLX_EXT_swap_control(load, userptr);
+    glad_glx_load_GLX_EXT_texture_from_pixmap(load, userptr);
+    glad_glx_load_GLX_MESA_agp_offset(load, userptr);
+    glad_glx_load_GLX_MESA_copy_sub_buffer(load, userptr);
+    glad_glx_load_GLX_MESA_pixmap_colormap(load, userptr);
+    glad_glx_load_GLX_MESA_query_renderer(load, userptr);
+    glad_glx_load_GLX_MESA_release_buffers(load, userptr);
+    glad_glx_load_GLX_MESA_set_3dfx_mode(load, userptr);
+    glad_glx_load_GLX_MESA_swap_control(load, userptr);
+    glad_glx_load_GLX_NV_copy_buffer(load, userptr);
+    glad_glx_load_GLX_NV_copy_image(load, userptr);
+    glad_glx_load_GLX_NV_delay_before_swap(load, userptr);
+    glad_glx_load_GLX_NV_present_video(load, userptr);
+    glad_glx_load_GLX_NV_swap_group(load, userptr);
+    glad_glx_load_GLX_NV_video_capture(load, userptr);
+    glad_glx_load_GLX_NV_video_out(load, userptr);
+    glad_glx_load_GLX_OML_sync_control(load, userptr);
+    glad_glx_load_GLX_SGIX_fbconfig(load, userptr);
+    glad_glx_load_GLX_SGIX_hyperpipe(load, userptr);
+    glad_glx_load_GLX_SGIX_pbuffer(load, userptr);
+    glad_glx_load_GLX_SGIX_swap_barrier(load, userptr);
+    glad_glx_load_GLX_SGIX_swap_group(load, userptr);
+    glad_glx_load_GLX_SGIX_video_resize(load, userptr);
+    glad_glx_load_GLX_SGI_cushion(load, userptr);
+    glad_glx_load_GLX_SGI_make_current_read(load, userptr);
+    glad_glx_load_GLX_SGI_swap_control(load, userptr);
+    glad_glx_load_GLX_SGI_video_sync(load, userptr);
+    glad_glx_load_GLX_SUN_get_transparent_index(load, userptr);
+
+    return version;
+}
+
+int gladLoadGLX(Display *display, int screen, GLADloadfunc load) {
+    return gladLoadGLXUserPtr(display, screen, glad_glx_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+
+#ifdef GLAD_GLX
+
+#ifndef GLAD_LOADER_LIBRARY_C_
+#define GLAD_LOADER_LIBRARY_C_
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#if GLAD_PLATFORM_WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+
+static void* glad_get_dlopen_handle(const char *lib_names[], int length) {
+    void *handle = NULL;
+    int i;
+
+    for (i = 0; i < length; ++i) {
+#if GLAD_PLATFORM_WIN32
+  #if GLAD_PLATFORM_UWP
+        size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR);
+        LPWSTR buffer = (LPWSTR) malloc(buffer_size);
+        if (buffer != NULL) {
+            int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size);
+            if (ret != 0) {
+                handle = (void*) LoadPackagedLibrary(buffer, 0);
+            }
+            free((void*) buffer);
+        }
+  #else
+        handle = (void*) LoadLibraryA(lib_names[i]);
+  #endif
+#else
+        handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL);
+#endif
+        if (handle != NULL) {
+            return handle;
+        }
+    }
+
+    return NULL;
+}
+
+static void glad_close_dlopen_handle(void* handle) {
+    if (handle != NULL) {
+#if GLAD_PLATFORM_WIN32
+        FreeLibrary((HMODULE) handle);
+#else
+        dlclose(handle);
+#endif
+    }
+}
+
+static GLADapiproc glad_dlsym_handle(void* handle, const char *name) {
+    if (handle == NULL) {
+        return NULL;
+    }
+
+#if GLAD_PLATFORM_WIN32
+    return (GLADapiproc) GetProcAddress((HMODULE) handle, name);
+#else
+    return GLAD_GNUC_EXTENSION (GLADapiproc) dlsym(handle, name);
+#endif
+}
+
+#endif /* GLAD_LOADER_LIBRARY_C_ */
+
+typedef void* (GLAD_API_PTR *GLADglxprocaddrfunc)(const char*);
+
+static GLADapiproc glad_glx_get_proc(const char *name, void *userptr) {
+    return GLAD_GNUC_EXTENSION ((GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static void* _glx_handle;
+
+int gladLoaderLoadGLX(Display *display, int screen) {
+    static const char *NAMES[] = {
+#if defined __CYGWIN__
+        "libGL-1.so",
+#endif
+        "libGL.so.1",
+        "libGL.so"
+    };
+
+    int version = 0;
+    int did_load = 0;
+    GLADglxprocaddrfunc loader;
+
+    if (_glx_handle == NULL) {
+        _glx_handle = glad_get_dlopen_handle(NAMES, sizeof(NAMES) / sizeof(NAMES[0]));
+        did_load = _glx_handle != NULL;
+    }
+
+    if (_glx_handle != NULL) {
+        loader = (GLADglxprocaddrfunc) glad_dlsym_handle(_glx_handle, "glXGetProcAddressARB");
+        if (loader != NULL) {
+            version = gladLoadGLXUserPtr(display, screen, glad_glx_get_proc, GLAD_GNUC_EXTENSION (void*) loader);
+        }
+
+        if (!version && did_load) {
+            glad_close_dlopen_handle(_glx_handle);
+            _glx_handle = NULL;
+        }
+    }
+
+    return version;
+}
+
+void gladLoaderUnloadGLX() {
+    if (_glx_handle != NULL) {
+        glad_close_dlopen_handle(_glx_handle);
+        _glx_handle = NULL;
+    }
+}
+
+#endif /* GLAD_GLX */
+
+#endif /* GLAD_GLX_IMPLEMENTATION */
+

+ 1589 - 0
package-system/glad-multiplatform/glad/include/glad/wgl.h

@@ -0,0 +1,1589 @@
+/**
+ * Loader generated by glad 2.0.0-beta on Thu Jan 24 22:47:37 2019
+ *
+ * Generator: C/C++
+ * Specification: wgl
+ * Extensions: 56
+ *
+ * APIs:
+ *  - wgl=1.0
+ *
+ * Options:
+ *  - MX_GLOBAL = False
+ *  - LOADER = True
+ *  - ALIAS = False
+ *  - HEADER_ONLY = True
+ *  - DEBUG = False
+ *  - MX = False
+ *
+ * Commandline:
+ *    --api='wgl=1.0' --extensions='WGL_3DFX_multisample,WGL_3DL_stereo_control,WGL_AMD_gpu_association,WGL_ARB_buffer_region,WGL_ARB_context_flush_control,WGL_ARB_create_context,WGL_ARB_create_context_no_error,WGL_ARB_create_context_profile,WGL_ARB_create_context_robustness,WGL_ARB_extensions_string,WGL_ARB_framebuffer_sRGB,WGL_ARB_make_current_read,WGL_ARB_multisample,WGL_ARB_pbuffer,WGL_ARB_pixel_format,WGL_ARB_pixel_format_float,WGL_ARB_render_texture,WGL_ARB_robustness_application_isolation,WGL_ARB_robustness_share_group_isolation,WGL_ATI_pixel_format_float,WGL_ATI_render_texture_rectangle,WGL_EXT_colorspace,WGL_EXT_create_context_es2_profile,WGL_EXT_create_context_es_profile,WGL_EXT_depth_float,WGL_EXT_display_color_table,WGL_EXT_extensions_string,WGL_EXT_framebuffer_sRGB,WGL_EXT_make_current_read,WGL_EXT_multisample,WGL_EXT_pbuffer,WGL_EXT_pixel_format,WGL_EXT_pixel_format_packed_float,WGL_EXT_swap_control,WGL_EXT_swap_control_tear,WGL_I3D_digital_video_control,WGL_I3D_gamma,WGL_I3D_genlock,WGL_I3D_image_buffer,WGL_I3D_swap_frame_lock,WGL_I3D_swap_frame_usage,WGL_NV_DX_interop,WGL_NV_DX_interop2,WGL_NV_copy_image,WGL_NV_delay_before_swap,WGL_NV_float_buffer,WGL_NV_gpu_affinity,WGL_NV_multisample_coverage,WGL_NV_present_video,WGL_NV_render_depth_texture,WGL_NV_render_texture_rectangle,WGL_NV_swap_group,WGL_NV_vertex_array_range,WGL_NV_video_capture,WGL_NV_video_output,WGL_OML_sync_control' c --loader --header-only
+ *
+ * Online:
+ *    http://glad.sh/#api=wgl%3D1.0&extensions=WGL_3DFX_multisample%2CWGL_3DL_stereo_control%2CWGL_AMD_gpu_association%2CWGL_ARB_buffer_region%2CWGL_ARB_context_flush_control%2CWGL_ARB_create_context%2CWGL_ARB_create_context_no_error%2CWGL_ARB_create_context_profile%2CWGL_ARB_create_context_robustness%2CWGL_ARB_extensions_string%2CWGL_ARB_framebuffer_sRGB%2CWGL_ARB_make_current_read%2CWGL_ARB_multisample%2CWGL_ARB_pbuffer%2CWGL_ARB_pixel_format%2CWGL_ARB_pixel_format_float%2CWGL_ARB_render_texture%2CWGL_ARB_robustness_application_isolation%2CWGL_ARB_robustness_share_group_isolation%2CWGL_ATI_pixel_format_float%2CWGL_ATI_render_texture_rectangle%2CWGL_EXT_colorspace%2CWGL_EXT_create_context_es2_profile%2CWGL_EXT_create_context_es_profile%2CWGL_EXT_depth_float%2CWGL_EXT_display_color_table%2CWGL_EXT_extensions_string%2CWGL_EXT_framebuffer_sRGB%2CWGL_EXT_make_current_read%2CWGL_EXT_multisample%2CWGL_EXT_pbuffer%2CWGL_EXT_pixel_format%2CWGL_EXT_pixel_format_packed_float%2CWGL_EXT_swap_control%2CWGL_EXT_swap_control_tear%2CWGL_I3D_digital_video_control%2CWGL_I3D_gamma%2CWGL_I3D_genlock%2CWGL_I3D_image_buffer%2CWGL_I3D_swap_frame_lock%2CWGL_I3D_swap_frame_usage%2CWGL_NV_DX_interop%2CWGL_NV_DX_interop2%2CWGL_NV_copy_image%2CWGL_NV_delay_before_swap%2CWGL_NV_float_buffer%2CWGL_NV_gpu_affinity%2CWGL_NV_multisample_coverage%2CWGL_NV_present_video%2CWGL_NV_render_depth_texture%2CWGL_NV_render_texture_rectangle%2CWGL_NV_swap_group%2CWGL_NV_vertex_array_range%2CWGL_NV_video_capture%2CWGL_NV_video_output%2CWGL_OML_sync_control&generator=c&options=LOADER%2CHEADER_ONLY
+ *
+ */
+
+#ifndef GLAD_WGL_H_
+#define GLAD_WGL_H_
+
+#include <windows.h>
+#include <glad/gl.h>
+
+#define GLAD_WGL
+#define GLAD_OPTION_WGL_LOADER
+#define GLAD_OPTION_WGL_HEADER_ONLY
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#ifndef GLAD_PLATFORM_WIN32
+  #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+    #define GLAD_PLATFORM_WIN32 1
+  #else
+    #define GLAD_PLATFORM_WIN32 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_APPLE
+  #ifdef __APPLE__
+    #define GLAD_PLATFORM_APPLE 1
+  #else
+    #define GLAD_PLATFORM_APPLE 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_EMSCRIPTEN
+  #ifdef __EMSCRIPTEN__
+    #define GLAD_PLATFORM_EMSCRIPTEN 1
+  #else
+    #define GLAD_PLATFORM_EMSCRIPTEN 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+  #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+    #ifdef __has_include
+      #if __has_include(<winapifamily.h>)
+        #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+      #endif
+    #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+      #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+    #endif
+  #endif
+
+  #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+    #include <winapifamily.h>
+    #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      #define GLAD_PLATFORM_UWP 1
+    #endif
+  #endif
+
+  #ifndef GLAD_PLATFORM_UWP
+    #define GLAD_PLATFORM_UWP 0
+  #endif
+#endif
+
+#ifdef __GNUC__
+  #define GLAD_GNUC_EXTENSION __extension__
+#else
+  #define GLAD_GNUC_EXTENSION
+#endif
+
+#ifndef GLAD_API_CALL
+  #if defined(GLAD_API_CALL_EXPORT)
+    #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+      #if defined(GLAD_API_CALL_EXPORT_BUILD)
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllexport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllexport) extern
+        #endif
+      #else
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllimport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllimport) extern
+        #endif
+      #endif
+    #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+      #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
+    #else
+      #define GLAD_API_CALL extern
+    #endif
+  #else
+    #define GLAD_API_CALL extern
+  #endif
+#endif
+
+#ifdef APIENTRY
+  #define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+  #define GLAD_API_PTR __stdcall
+#else
+  #define GLAD_API_PTR
+#endif
+
+#ifndef GLAPI
+#define GLAPI GLAD_API_CALL
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY GLAD_API_PTR
+#endif
+
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+typedef void (*GLADapiproc)(void);
+
+typedef GLADapiproc (*GLADloadfunc)(const char *name);
+typedef GLADapiproc (*GLADuserptrloadfunc)(const char *name, void *userptr);
+
+typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
+#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
+#define ERROR_INVALID_PROFILE_ARB 0x2096
+#define ERROR_INVALID_VERSION_ARB 0x2095
+#define ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#define WGL_ACCELERATION_ARB 0x2003
+#define WGL_ACCELERATION_EXT 0x2003
+#define WGL_ACCESS_READ_ONLY_NV 0x00000000
+#define WGL_ACCESS_READ_WRITE_NV 0x00000001
+#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002
+#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
+#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
+#define WGL_ACCUM_BITS_ARB 0x201D
+#define WGL_ACCUM_BITS_EXT 0x201D
+#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
+#define WGL_ACCUM_BLUE_BITS_EXT 0x2020
+#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
+#define WGL_ACCUM_GREEN_BITS_EXT 0x201F
+#define WGL_ACCUM_RED_BITS_ARB 0x201E
+#define WGL_ACCUM_RED_BITS_EXT 0x201E
+#define WGL_ALPHA_BITS_ARB 0x201B
+#define WGL_ALPHA_BITS_EXT 0x201B
+#define WGL_ALPHA_SHIFT_ARB 0x201C
+#define WGL_ALPHA_SHIFT_EXT 0x201C
+#define WGL_AUX0_ARB 0x2087
+#define WGL_AUX1_ARB 0x2088
+#define WGL_AUX2_ARB 0x2089
+#define WGL_AUX3_ARB 0x208A
+#define WGL_AUX4_ARB 0x208B
+#define WGL_AUX5_ARB 0x208C
+#define WGL_AUX6_ARB 0x208D
+#define WGL_AUX7_ARB 0x208E
+#define WGL_AUX8_ARB 0x208F
+#define WGL_AUX9_ARB 0x2090
+#define WGL_AUX_BUFFERS_ARB 0x2024
+#define WGL_AUX_BUFFERS_EXT 0x2024
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
+#define WGL_BACK_LEFT_ARB 0x2085
+#define WGL_BACK_RIGHT_ARB 0x2086
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071
+#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070
+#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1
+#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2
+#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0
+#define WGL_BLUE_BITS_ARB 0x2019
+#define WGL_BLUE_BITS_EXT 0x2019
+#define WGL_BLUE_SHIFT_ARB 0x201A
+#define WGL_BLUE_SHIFT_EXT 0x201A
+#define WGL_COLORSPACE_EXT 0x309D
+#define WGL_COLORSPACE_LINEAR_EXT 0x308A
+#define WGL_COLORSPACE_SRGB_EXT 0x3089
+#define WGL_COLOR_BITS_ARB 0x2014
+#define WGL_COLOR_BITS_EXT 0x2014
+#define WGL_COLOR_SAMPLES_NV 0x20B9
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define WGL_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define WGL_CONTEXT_FLAGS_ARB 0x2094
+#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
+#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define WGL_CONTEXT_OPENGL_NO_ERROR_ARB 0x31B3
+#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define WGL_COVERAGE_SAMPLES_NV 0x2042
+#define WGL_CUBE_MAP_FACE_ARB 0x207C
+#define WGL_DEPTH_BITS_ARB 0x2022
+#define WGL_DEPTH_BITS_EXT 0x2022
+#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
+#define WGL_DEPTH_COMPONENT_NV 0x20A7
+#define WGL_DEPTH_FLOAT_EXT 0x2040
+#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+#define WGL_DOUBLE_BUFFER_ARB 0x2011
+#define WGL_DOUBLE_BUFFER_EXT 0x2011
+#define WGL_DRAW_TO_BITMAP_ARB 0x2002
+#define WGL_DRAW_TO_BITMAP_EXT 0x2002
+#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
+#define WGL_DRAW_TO_PBUFFER_EXT 0x202D
+#define WGL_DRAW_TO_WINDOW_ARB 0x2001
+#define WGL_DRAW_TO_WINDOW_EXT 0x2001
+#define WGL_FLOAT_COMPONENTS_NV 0x20B0
+#define WGL_FONT_LINES 0
+#define WGL_FONT_POLYGONS 1
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_FRONT_LEFT_ARB 0x2083
+#define WGL_FRONT_RIGHT_ARB 0x2084
+#define WGL_FULL_ACCELERATION_ARB 0x2027
+#define WGL_FULL_ACCELERATION_EXT 0x2027
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
+#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
+#define WGL_GENERIC_ACCELERATION_ARB 0x2026
+#define WGL_GENERIC_ACCELERATION_EXT 0x2026
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GPU_CLOCK_AMD 0x21A4
+#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define WGL_GPU_NUM_PIPES_AMD 0x21A5
+#define WGL_GPU_NUM_RB_AMD 0x21A7
+#define WGL_GPU_NUM_SIMD_AMD 0x21A6
+#define WGL_GPU_NUM_SPI_AMD 0x21A8
+#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define WGL_GPU_RAM_AMD 0x21A3
+#define WGL_GPU_RENDERER_STRING_AMD 0x1F01
+#define WGL_GPU_VENDOR_AMD 0x1F00
+#define WGL_GREEN_BITS_ARB 0x2017
+#define WGL_GREEN_BITS_EXT 0x2017
+#define WGL_GREEN_SHIFT_ARB 0x2018
+#define WGL_GREEN_SHIFT_EXT 0x2018
+#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
+#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
+#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
+#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
+#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
+#define WGL_MIPMAP_LEVEL_ARB 0x207B
+#define WGL_MIPMAP_TEXTURE_ARB 0x2074
+#define WGL_NEED_PALETTE_ARB 0x2004
+#define WGL_NEED_PALETTE_EXT 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
+#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
+#define WGL_NO_ACCELERATION_ARB 0x2025
+#define WGL_NO_ACCELERATION_EXT 0x2025
+#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_NUMBER_OVERLAYS_ARB 0x2008
+#define WGL_NUMBER_OVERLAYS_EXT 0x2008
+#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
+#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
+#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
+#define WGL_NUMBER_UNDERLAYS_EXT 0x2009
+#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
+#define WGL_PBUFFER_HEIGHT_ARB 0x2035
+#define WGL_PBUFFER_HEIGHT_EXT 0x2035
+#define WGL_PBUFFER_LARGEST_ARB 0x2033
+#define WGL_PBUFFER_LARGEST_EXT 0x2033
+#define WGL_PBUFFER_LOST_ARB 0x2036
+#define WGL_PBUFFER_WIDTH_ARB 0x2034
+#define WGL_PBUFFER_WIDTH_EXT 0x2034
+#define WGL_PIXEL_TYPE_ARB 0x2013
+#define WGL_PIXEL_TYPE_EXT 0x2013
+#define WGL_RED_BITS_ARB 0x2015
+#define WGL_RED_BITS_EXT 0x2015
+#define WGL_RED_SHIFT_ARB 0x2016
+#define WGL_RED_SHIFT_EXT 0x2016
+#define WGL_SAMPLES_3DFX 0x2061
+#define WGL_SAMPLES_ARB 0x2042
+#define WGL_SAMPLES_EXT 0x2042
+#define WGL_SAMPLE_BUFFERS_3DFX 0x2060
+#define WGL_SAMPLE_BUFFERS_ARB 0x2041
+#define WGL_SAMPLE_BUFFERS_EXT 0x2041
+#define WGL_SHARE_ACCUM_ARB 0x200E
+#define WGL_SHARE_ACCUM_EXT 0x200E
+#define WGL_SHARE_DEPTH_ARB 0x200C
+#define WGL_SHARE_DEPTH_EXT 0x200C
+#define WGL_SHARE_STENCIL_ARB 0x200D
+#define WGL_SHARE_STENCIL_EXT 0x200D
+#define WGL_STENCIL_BITS_ARB 0x2023
+#define WGL_STENCIL_BITS_EXT 0x2023
+#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
+#define WGL_STEREO_ARB 0x2012
+#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056
+#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055
+#define WGL_STEREO_EXT 0x2012
+#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058
+#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057
+#define WGL_SUPPORT_GDI_ARB 0x200F
+#define WGL_SUPPORT_GDI_EXT 0x200F
+#define WGL_SUPPORT_OPENGL_ARB 0x2010
+#define WGL_SUPPORT_OPENGL_EXT 0x2010
+#define WGL_SWAP_COPY_ARB 0x2029
+#define WGL_SWAP_COPY_EXT 0x2029
+#define WGL_SWAP_EXCHANGE_ARB 0x2028
+#define WGL_SWAP_EXCHANGE_EXT 0x2028
+#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
+#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
+#define WGL_SWAP_MAIN_PLANE 0x00000001
+#define WGL_SWAP_METHOD_ARB 0x2007
+#define WGL_SWAP_METHOD_EXT 0x2007
+#define WGL_SWAP_OVERLAY1 0x00000002
+#define WGL_SWAP_OVERLAY10 0x00000400
+#define WGL_SWAP_OVERLAY11 0x00000800
+#define WGL_SWAP_OVERLAY12 0x00001000
+#define WGL_SWAP_OVERLAY13 0x00002000
+#define WGL_SWAP_OVERLAY14 0x00004000
+#define WGL_SWAP_OVERLAY15 0x00008000
+#define WGL_SWAP_OVERLAY2 0x00000004
+#define WGL_SWAP_OVERLAY3 0x00000008
+#define WGL_SWAP_OVERLAY4 0x00000010
+#define WGL_SWAP_OVERLAY5 0x00000020
+#define WGL_SWAP_OVERLAY6 0x00000040
+#define WGL_SWAP_OVERLAY7 0x00000080
+#define WGL_SWAP_OVERLAY8 0x00000100
+#define WGL_SWAP_OVERLAY9 0x00000200
+#define WGL_SWAP_UNDEFINED_ARB 0x202A
+#define WGL_SWAP_UNDEFINED_EXT 0x202A
+#define WGL_SWAP_UNDERLAY1 0x00010000
+#define WGL_SWAP_UNDERLAY10 0x02000000
+#define WGL_SWAP_UNDERLAY11 0x04000000
+#define WGL_SWAP_UNDERLAY12 0x08000000
+#define WGL_SWAP_UNDERLAY13 0x10000000
+#define WGL_SWAP_UNDERLAY14 0x20000000
+#define WGL_SWAP_UNDERLAY15 0x40000000
+#define WGL_SWAP_UNDERLAY2 0x00020000
+#define WGL_SWAP_UNDERLAY3 0x00040000
+#define WGL_SWAP_UNDERLAY4 0x00080000
+#define WGL_SWAP_UNDERLAY5 0x00100000
+#define WGL_SWAP_UNDERLAY6 0x00200000
+#define WGL_SWAP_UNDERLAY7 0x00400000
+#define WGL_SWAP_UNDERLAY8 0x00800000
+#define WGL_SWAP_UNDERLAY9 0x01000000
+#define WGL_TEXTURE_1D_ARB 0x2079
+#define WGL_TEXTURE_2D_ARB 0x207A
+#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8
+#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7
+#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6
+#define WGL_TEXTURE_FLOAT_R_NV 0x20B5
+#define WGL_TEXTURE_FORMAT_ARB 0x2072
+#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5
+#define WGL_TEXTURE_RECTANGLE_NV 0x20A2
+#define WGL_TEXTURE_RGBA_ARB 0x2076
+#define WGL_TEXTURE_RGB_ARB 0x2075
+#define WGL_TEXTURE_TARGET_ARB 0x2073
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_ARB 0x200A
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_EXT 0x200A
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
+#define WGL_TRANSPARENT_VALUE_EXT 0x200B
+#define WGL_TYPE_COLORINDEX_ARB 0x202C
+#define WGL_TYPE_COLORINDEX_EXT 0x202C
+#define WGL_TYPE_RGBA_ARB 0x202B
+#define WGL_TYPE_RGBA_EXT 0x202B
+#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
+#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0
+#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+#define WGL_UNIQUE_ID_NV 0x20CE
+#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4
+#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define WGL_VIDEO_OUT_COLOR_NV 0x20C3
+#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5
+#define WGL_VIDEO_OUT_FIELD_1 0x20C9
+#define WGL_VIDEO_OUT_FIELD_2 0x20CA
+#define WGL_VIDEO_OUT_FRAME 0x20C8
+#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB
+#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct _GPU_DEVICE {
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  Flags;
+    RECT   rcVirtualScreen;
+};
+DECLARE_HANDLE(HPBUFFERARB);
+DECLARE_HANDLE(HPBUFFEREXT);
+DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV);
+DECLARE_HANDLE(HPVIDEODEV);
+DECLARE_HANDLE(HPGPUNV);
+DECLARE_HANDLE(HGPUNV);
+DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
+typedef struct _GPU_DEVICE GPU_DEVICE;
+typedef struct _GPU_DEVICE *PGPU_DEVICE;
+
+
+#define WGL_VERSION_1_0 1
+GLAD_API_CALL int GLAD_WGL_VERSION_1_0;
+#define WGL_3DFX_multisample 1
+GLAD_API_CALL int GLAD_WGL_3DFX_multisample;
+#define WGL_3DL_stereo_control 1
+GLAD_API_CALL int GLAD_WGL_3DL_stereo_control;
+#define WGL_AMD_gpu_association 1
+GLAD_API_CALL int GLAD_WGL_AMD_gpu_association;
+#define WGL_ARB_buffer_region 1
+GLAD_API_CALL int GLAD_WGL_ARB_buffer_region;
+#define WGL_ARB_context_flush_control 1
+GLAD_API_CALL int GLAD_WGL_ARB_context_flush_control;
+#define WGL_ARB_create_context 1
+GLAD_API_CALL int GLAD_WGL_ARB_create_context;
+#define WGL_ARB_create_context_no_error 1
+GLAD_API_CALL int GLAD_WGL_ARB_create_context_no_error;
+#define WGL_ARB_create_context_profile 1
+GLAD_API_CALL int GLAD_WGL_ARB_create_context_profile;
+#define WGL_ARB_create_context_robustness 1
+GLAD_API_CALL int GLAD_WGL_ARB_create_context_robustness;
+#define WGL_ARB_extensions_string 1
+GLAD_API_CALL int GLAD_WGL_ARB_extensions_string;
+#define WGL_ARB_framebuffer_sRGB 1
+GLAD_API_CALL int GLAD_WGL_ARB_framebuffer_sRGB;
+#define WGL_ARB_make_current_read 1
+GLAD_API_CALL int GLAD_WGL_ARB_make_current_read;
+#define WGL_ARB_multisample 1
+GLAD_API_CALL int GLAD_WGL_ARB_multisample;
+#define WGL_ARB_pbuffer 1
+GLAD_API_CALL int GLAD_WGL_ARB_pbuffer;
+#define WGL_ARB_pixel_format 1
+GLAD_API_CALL int GLAD_WGL_ARB_pixel_format;
+#define WGL_ARB_pixel_format_float 1
+GLAD_API_CALL int GLAD_WGL_ARB_pixel_format_float;
+#define WGL_ARB_render_texture 1
+GLAD_API_CALL int GLAD_WGL_ARB_render_texture;
+#define WGL_ARB_robustness_application_isolation 1
+GLAD_API_CALL int GLAD_WGL_ARB_robustness_application_isolation;
+#define WGL_ARB_robustness_share_group_isolation 1
+GLAD_API_CALL int GLAD_WGL_ARB_robustness_share_group_isolation;
+#define WGL_ATI_pixel_format_float 1
+GLAD_API_CALL int GLAD_WGL_ATI_pixel_format_float;
+#define WGL_ATI_render_texture_rectangle 1
+GLAD_API_CALL int GLAD_WGL_ATI_render_texture_rectangle;
+#define WGL_EXT_colorspace 1
+GLAD_API_CALL int GLAD_WGL_EXT_colorspace;
+#define WGL_EXT_create_context_es2_profile 1
+GLAD_API_CALL int GLAD_WGL_EXT_create_context_es2_profile;
+#define WGL_EXT_create_context_es_profile 1
+GLAD_API_CALL int GLAD_WGL_EXT_create_context_es_profile;
+#define WGL_EXT_depth_float 1
+GLAD_API_CALL int GLAD_WGL_EXT_depth_float;
+#define WGL_EXT_display_color_table 1
+GLAD_API_CALL int GLAD_WGL_EXT_display_color_table;
+#define WGL_EXT_extensions_string 1
+GLAD_API_CALL int GLAD_WGL_EXT_extensions_string;
+#define WGL_EXT_framebuffer_sRGB 1
+GLAD_API_CALL int GLAD_WGL_EXT_framebuffer_sRGB;
+#define WGL_EXT_make_current_read 1
+GLAD_API_CALL int GLAD_WGL_EXT_make_current_read;
+#define WGL_EXT_multisample 1
+GLAD_API_CALL int GLAD_WGL_EXT_multisample;
+#define WGL_EXT_pbuffer 1
+GLAD_API_CALL int GLAD_WGL_EXT_pbuffer;
+#define WGL_EXT_pixel_format 1
+GLAD_API_CALL int GLAD_WGL_EXT_pixel_format;
+#define WGL_EXT_pixel_format_packed_float 1
+GLAD_API_CALL int GLAD_WGL_EXT_pixel_format_packed_float;
+#define WGL_EXT_swap_control 1
+GLAD_API_CALL int GLAD_WGL_EXT_swap_control;
+#define WGL_EXT_swap_control_tear 1
+GLAD_API_CALL int GLAD_WGL_EXT_swap_control_tear;
+#define WGL_I3D_digital_video_control 1
+GLAD_API_CALL int GLAD_WGL_I3D_digital_video_control;
+#define WGL_I3D_gamma 1
+GLAD_API_CALL int GLAD_WGL_I3D_gamma;
+#define WGL_I3D_genlock 1
+GLAD_API_CALL int GLAD_WGL_I3D_genlock;
+#define WGL_I3D_image_buffer 1
+GLAD_API_CALL int GLAD_WGL_I3D_image_buffer;
+#define WGL_I3D_swap_frame_lock 1
+GLAD_API_CALL int GLAD_WGL_I3D_swap_frame_lock;
+#define WGL_I3D_swap_frame_usage 1
+GLAD_API_CALL int GLAD_WGL_I3D_swap_frame_usage;
+#define WGL_NV_DX_interop 1
+GLAD_API_CALL int GLAD_WGL_NV_DX_interop;
+#define WGL_NV_DX_interop2 1
+GLAD_API_CALL int GLAD_WGL_NV_DX_interop2;
+#define WGL_NV_copy_image 1
+GLAD_API_CALL int GLAD_WGL_NV_copy_image;
+#define WGL_NV_delay_before_swap 1
+GLAD_API_CALL int GLAD_WGL_NV_delay_before_swap;
+#define WGL_NV_float_buffer 1
+GLAD_API_CALL int GLAD_WGL_NV_float_buffer;
+#define WGL_NV_gpu_affinity 1
+GLAD_API_CALL int GLAD_WGL_NV_gpu_affinity;
+#define WGL_NV_multisample_coverage 1
+GLAD_API_CALL int GLAD_WGL_NV_multisample_coverage;
+#define WGL_NV_present_video 1
+GLAD_API_CALL int GLAD_WGL_NV_present_video;
+#define WGL_NV_render_depth_texture 1
+GLAD_API_CALL int GLAD_WGL_NV_render_depth_texture;
+#define WGL_NV_render_texture_rectangle 1
+GLAD_API_CALL int GLAD_WGL_NV_render_texture_rectangle;
+#define WGL_NV_swap_group 1
+GLAD_API_CALL int GLAD_WGL_NV_swap_group;
+#define WGL_NV_vertex_array_range 1
+GLAD_API_CALL int GLAD_WGL_NV_vertex_array_range;
+#define WGL_NV_video_capture 1
+GLAD_API_CALL int GLAD_WGL_NV_video_capture;
+#define WGL_NV_video_output 1
+GLAD_API_CALL int GLAD_WGL_NV_video_output;
+#define WGL_OML_sync_control 1
+GLAD_API_CALL int GLAD_WGL_OML_sync_control;
+
+
+typedef int (GLAD_API_PTR *PFNCHOOSEPIXELFORMATPROC)(HDC   hDc, const  PIXELFORMATDESCRIPTOR  * pPfd);
+typedef int (GLAD_API_PTR *PFNDESCRIBEPIXELFORMATPROC)(HDC   hdc, int  ipfd, UINT   cjpfd, const  PIXELFORMATDESCRIPTOR  * ppfd);
+typedef UINT (GLAD_API_PTR *PFNGETENHMETAFILEPIXELFORMATPROC)(HENHMETAFILE   hemf, const  PIXELFORMATDESCRIPTOR  * ppfd);
+typedef int (GLAD_API_PTR *PFNGETPIXELFORMATPROC)(HDC   hdc);
+typedef BOOL (GLAD_API_PTR *PFNSETPIXELFORMATPROC)(HDC   hdc, int  ipfd, const  PIXELFORMATDESCRIPTOR  * ppfd);
+typedef BOOL (GLAD_API_PTR *PFNSWAPBUFFERSPROC)(HDC   hdc);
+typedef void * (GLAD_API_PTR *PFNWGLALLOCATEMEMORYNVPROC)(GLsizei   size, GLfloat   readfreq, GLfloat   writefreq, GLfloat   priority);
+typedef BOOL (GLAD_API_PTR *PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC   hDC, const  HANDLE  * pEvent, const  LPVOID  * pAddress, const  DWORD  * pSize, UINT   count);
+typedef BOOL (GLAD_API_PTR *PFNWGLBEGINFRAMETRACKINGI3DPROC)(void);
+typedef GLboolean (GLAD_API_PTR *PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort   id);
+typedef BOOL (GLAD_API_PTR *PFNWGLBINDSWAPBARRIERNVPROC)(GLuint   group, GLuint   barrier);
+typedef BOOL (GLAD_API_PTR *PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB   hPbuffer, int  iBuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)(UINT   uVideoSlot, HVIDEOINPUTDEVICENV   hDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLBINDVIDEODEVICENVPROC)(HDC   hDC, unsigned int  uVideoSlot, HVIDEOOUTPUTDEVICENV   hVideoDevice, const int * piAttribList);
+typedef BOOL (GLAD_API_PTR *PFNWGLBINDVIDEOIMAGENVPROC)(HPVIDEODEV   hVideoDevice, HPBUFFERARB   hPbuffer, int  iVideoBuffer);
+typedef VOID (GLAD_API_PTR *PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)(HGLRC   dstCtx, GLint   srcX0, GLint   srcY0, GLint   srcX1, GLint   srcY1, GLint   dstX0, GLint   dstY0, GLint   dstX1, GLint   dstY1, GLbitfield   mask, GLenum   filter);
+typedef BOOL (GLAD_API_PTR *PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC   hdc, const int * piAttribIList, const  FLOAT  * pfAttribFList, UINT   nMaxFormats, int * piFormats, UINT  * nNumFormats);
+typedef BOOL (GLAD_API_PTR *PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC   hdc, const int * piAttribIList, const  FLOAT  * pfAttribFList, UINT   nMaxFormats, int * piFormats, UINT  * nNumFormats);
+typedef BOOL (GLAD_API_PTR *PFNWGLCOPYCONTEXTPROC)(HGLRC   hglrcSrc, HGLRC   hglrcDst, UINT   mask);
+typedef BOOL (GLAD_API_PTR *PFNWGLCOPYIMAGESUBDATANVPROC)(HGLRC   hSrcRC, GLuint   srcName, GLenum   srcTarget, GLint   srcLevel, GLint   srcX, GLint   srcY, GLint   srcZ, HGLRC   hDstRC, GLuint   dstName, GLenum   dstTarget, GLint   dstLevel, GLint   dstX, GLint   dstY, GLint   dstZ, GLsizei   width, GLsizei   height, GLsizei   depth);
+typedef HDC (GLAD_API_PTR *PFNWGLCREATEAFFINITYDCNVPROC)(const  HGPUNV  * phGpuList);
+typedef HGLRC (GLAD_API_PTR *PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)(UINT   id);
+typedef HGLRC (GLAD_API_PTR *PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(UINT   id, HGLRC   hShareContext, const int * attribList);
+typedef HANDLE (GLAD_API_PTR *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC   hDC, int  iLayerPlane, UINT   uType);
+typedef HGLRC (GLAD_API_PTR *PFNWGLCREATECONTEXTPROC)(HDC   hDc);
+typedef HGLRC (GLAD_API_PTR *PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC   hDC, HGLRC   hShareContext, const int * attribList);
+typedef GLboolean (GLAD_API_PTR *PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort   id);
+typedef LPVOID (GLAD_API_PTR *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC   hDC, DWORD   dwSize, UINT   uFlags);
+typedef HGLRC (GLAD_API_PTR *PFNWGLCREATELAYERCONTEXTPROC)(HDC   hDc, int  level);
+typedef HPBUFFERARB (GLAD_API_PTR *PFNWGLCREATEPBUFFERARBPROC)(HDC   hDC, int  iPixelFormat, int  iWidth, int  iHeight, const int * piAttribList);
+typedef HPBUFFEREXT (GLAD_API_PTR *PFNWGLCREATEPBUFFEREXTPROC)(HDC   hDC, int  iPixelFormat, int  iWidth, int  iHeight, const int * piAttribList);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXCLOSEDEVICENVPROC)(HANDLE   hDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXLOCKOBJECTSNVPROC)(HANDLE   hDevice, GLint   count, HANDLE  * hObjects);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXOBJECTACCESSNVPROC)(HANDLE   hObject, GLenum   access);
+typedef HANDLE (GLAD_API_PTR *PFNWGLDXOPENDEVICENVPROC)(void * dxDevice);
+typedef HANDLE (GLAD_API_PTR *PFNWGLDXREGISTEROBJECTNVPROC)(HANDLE   hDevice, void * dxObject, GLuint   name, GLenum   type, GLenum   access);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXSETRESOURCESHAREHANDLENVPROC)(void * dxObject, HANDLE   shareHandle);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXUNLOCKOBJECTSNVPROC)(HANDLE   hDevice, GLint   count, HANDLE  * hObjects);
+typedef BOOL (GLAD_API_PTR *PFNWGLDXUNREGISTEROBJECTNVPROC)(HANDLE   hDevice, HANDLE   hObject);
+typedef BOOL (GLAD_API_PTR *PFNWGLDELAYBEFORESWAPNVPROC)(HDC   hDC, GLfloat   seconds);
+typedef BOOL (GLAD_API_PTR *PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)(HGLRC   hglrc);
+typedef VOID (GLAD_API_PTR *PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE   hRegion);
+typedef BOOL (GLAD_API_PTR *PFNWGLDELETECONTEXTPROC)(HGLRC   oldContext);
+typedef BOOL (GLAD_API_PTR *PFNWGLDELETEDCNVPROC)(HDC   hdc);
+typedef BOOL (GLAD_API_PTR *PFNWGLDESCRIBELAYERPLANEPROC)(HDC   hDc, int  pixelFormat, int  layerPlane, UINT   nBytes, const  LAYERPLANEDESCRIPTOR  * plpd);
+typedef VOID (GLAD_API_PTR *PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort   id);
+typedef BOOL (GLAD_API_PTR *PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC   hDC, LPVOID   pAddress);
+typedef BOOL (GLAD_API_PTR *PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB   hPbuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT   hPbuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLDISABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLDISABLEGENLOCKI3DPROC)(HDC   hDC);
+typedef BOOL (GLAD_API_PTR *PFNWGLENABLEFRAMELOCKI3DPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLENABLEGENLOCKI3DPROC)(HDC   hDC);
+typedef BOOL (GLAD_API_PTR *PFNWGLENDFRAMETRACKINGI3DPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLENUMGPUDEVICESNVPROC)(HGPUNV   hGpu, UINT   iDeviceIndex, PGPU_DEVICE   lpGpuDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)(HDC   hAffinityDC, UINT   iGpuIndex, HGPUNV  * hGpu);
+typedef BOOL (GLAD_API_PTR *PFNWGLENUMGPUSNVPROC)(UINT   iGpuIndex, HGPUNV  * phGpu);
+typedef UINT (GLAD_API_PTR *PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)(HDC   hDc, HVIDEOINPUTDEVICENV  * phDeviceList);
+typedef int (GLAD_API_PTR *PFNWGLENUMERATEVIDEODEVICESNVPROC)(HDC   hDC, HVIDEOOUTPUTDEVICENV  * phDeviceList);
+typedef void (GLAD_API_PTR *PFNWGLFREEMEMORYNVPROC)(void * pointer);
+typedef BOOL (GLAD_API_PTR *PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC   hDC, UINT   uRate);
+typedef BOOL (GLAD_API_PTR *PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC   hDC, UINT   uDelay);
+typedef BOOL (GLAD_API_PTR *PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC   hDC, UINT   uEdge);
+typedef BOOL (GLAD_API_PTR *PFNWGLGENLOCKSOURCEI3DPROC)(HDC   hDC, UINT   uSource);
+typedef UINT (GLAD_API_PTR *PFNWGLGETCONTEXTGPUIDAMDPROC)(HGLRC   hglrc);
+typedef HGLRC (GLAD_API_PTR *PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)(void);
+typedef HGLRC (GLAD_API_PTR *PFNWGLGETCURRENTCONTEXTPROC)(void);
+typedef HDC (GLAD_API_PTR *PFNWGLGETCURRENTDCPROC)(void);
+typedef HDC (GLAD_API_PTR *PFNWGLGETCURRENTREADDCARBPROC)(void);
+typedef HDC (GLAD_API_PTR *PFNWGLGETCURRENTREADDCEXTPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC   hDC, int  iAttribute, int * piValue);
+typedef const char * (GLAD_API_PTR *PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC   hdc);
+typedef const char * (GLAD_API_PTR *PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETFRAMEUSAGEI3DPROC)(float * pUsage);
+typedef UINT (GLAD_API_PTR *PFNWGLGETGPUIDSAMDPROC)(UINT   maxCount, UINT  * ids);
+typedef INT (GLAD_API_PTR *PFNWGLGETGPUINFOAMDPROC)(UINT   id, int  property, GLenum   dataType, UINT   size, void * data);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGAMMATABLEI3DPROC)(HDC   hDC, int  iEntries, USHORT  * puRed, USHORT  * puGreen, USHORT  * puBlue);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC   hDC, int  iAttribute, int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC   hDC, UINT  * uRate);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC   hDC, UINT  * uDelay);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC   hDC, UINT  * uEdge);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC   hDC, UINT  * uSource);
+typedef int (GLAD_API_PTR *PFNWGLGETLAYERPALETTEENTRIESPROC)(HDC   hdc, int  iLayerPlane, int  iStart, int  cEntries, const  COLORREF  * pcr);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETMSCRATEOMLPROC)(HDC   hdc, INT32  * numerator, INT32  * denominator);
+typedef HDC (GLAD_API_PTR *PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB   hPbuffer);
+typedef HDC (GLAD_API_PTR *PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT   hPbuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC   hdc, int  iPixelFormat, int  iLayerPlane, UINT   nAttributes, const int * piAttributes, FLOAT  * pfValues);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC   hdc, int  iPixelFormat, int  iLayerPlane, UINT   nAttributes, int * piAttributes, FLOAT  * pfValues);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC   hdc, int  iPixelFormat, int  iLayerPlane, UINT   nAttributes, const int * piAttributes, int * piValues);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC   hdc, int  iPixelFormat, int  iLayerPlane, UINT   nAttributes, int * piAttributes, int * piValues);
+typedef PROC (GLAD_API_PTR *PFNWGLGETPROCADDRESSPROC)(LPCSTR   lpszProc);
+typedef int (GLAD_API_PTR *PFNWGLGETSWAPINTERVALEXTPROC)(void);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETSYNCVALUESOMLPROC)(HDC   hdc, INT64  * ust, INT64  * msc, INT64  * sbc);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETVIDEODEVICENVPROC)(HDC   hDC, int  numDevices, HPVIDEODEV  * hVideoDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLGETVIDEOINFONVPROC)(HPVIDEODEV   hpVideoDevice, unsigned long * pulCounterOutputPbuffer, unsigned long * pulCounterOutputVideo);
+typedef BOOL (GLAD_API_PTR *PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL  * pFlag);
+typedef BOOL (GLAD_API_PTR *PFNWGLISENABLEDGENLOCKI3DPROC)(HDC   hDC, BOOL  * pFlag);
+typedef BOOL (GLAD_API_PTR *PFNWGLJOINSWAPGROUPNVPROC)(HDC   hDC, GLuint   group);
+typedef GLboolean (GLAD_API_PTR *PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(const  GLushort  * table, GLuint   length);
+typedef BOOL (GLAD_API_PTR *PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)(HDC   hDc, HVIDEOINPUTDEVICENV   hDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(HGLRC   hglrc);
+typedef BOOL (GLAD_API_PTR *PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC   hDrawDC, HDC   hReadDC, HGLRC   hglrc);
+typedef BOOL (GLAD_API_PTR *PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC   hDrawDC, HDC   hReadDC, HGLRC   hglrc);
+typedef BOOL (GLAD_API_PTR *PFNWGLMAKECURRENTPROC)(HDC   hDc, HGLRC   newContext);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYCURRENTCONTEXTNVPROC)(int  iAttribute, int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYFRAMECOUNTNVPROC)(HDC   hDC, GLuint  * count);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL  * pFlag);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD  * pFrameCount, DWORD  * pMissedFrames, float * pLastMissedUsage);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC   hDC, UINT  * uMaxLineDelay, UINT  * uMaxPixelDelay);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYMAXSWAPGROUPSNVPROC)(HDC   hDC, GLuint  * maxGroups, GLuint  * maxBarriers);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB   hPbuffer, int  iAttribute, int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT   hPbuffer, int  iAttribute, int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYSWAPGROUPNVPROC)(HDC   hDC, GLuint  * group, GLuint  * barrier);
+typedef BOOL (GLAD_API_PTR *PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)(HDC   hDc, HVIDEOINPUTDEVICENV   hDevice, int  iAttribute, int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLREALIZELAYERPALETTEPROC)(HDC   hdc, int  iLayerPlane, BOOL   bRealize);
+typedef BOOL (GLAD_API_PTR *PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC   hDC, const  LPVOID  * pAddress, UINT   count);
+typedef int (GLAD_API_PTR *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB   hPbuffer, HDC   hDC);
+typedef int (GLAD_API_PTR *PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT   hPbuffer, HDC   hDC);
+typedef BOOL (GLAD_API_PTR *PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB   hPbuffer, int  iBuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)(HDC   hDc, HVIDEOINPUTDEVICENV   hDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLRELEASEVIDEODEVICENVPROC)(HPVIDEODEV   hVideoDevice);
+typedef BOOL (GLAD_API_PTR *PFNWGLRELEASEVIDEOIMAGENVPROC)(HPBUFFERARB   hPbuffer, int  iVideoBuffer);
+typedef BOOL (GLAD_API_PTR *PFNWGLRESETFRAMECOUNTNVPROC)(HDC   hDC);
+typedef BOOL (GLAD_API_PTR *PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE   hRegion, int  x, int  y, int  width, int  height, int  xSrc, int  ySrc);
+typedef BOOL (GLAD_API_PTR *PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE   hRegion, int  x, int  y, int  width, int  height);
+typedef BOOL (GLAD_API_PTR *PFNWGLSENDPBUFFERTOVIDEONVPROC)(HPBUFFERARB   hPbuffer, int  iBufferType, unsigned long * pulCounterPbuffer, BOOL   bBlock);
+typedef BOOL (GLAD_API_PTR *PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC   hDC, int  iAttribute, const int * piValue);
+typedef BOOL (GLAD_API_PTR *PFNWGLSETGAMMATABLEI3DPROC)(HDC   hDC, int  iEntries, const  USHORT  * puRed, const  USHORT  * puGreen, const  USHORT  * puBlue);
+typedef BOOL (GLAD_API_PTR *PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC   hDC, int  iAttribute, const int * piValue);
+typedef int (GLAD_API_PTR *PFNWGLSETLAYERPALETTEENTRIESPROC)(HDC   hdc, int  iLayerPlane, int  iStart, int  cEntries, const  COLORREF  * pcr);
+typedef BOOL (GLAD_API_PTR *PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB   hPbuffer, const int * piAttribList);
+typedef BOOL (GLAD_API_PTR *PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC   hDC, UINT   uState);
+typedef BOOL (GLAD_API_PTR *PFNWGLSHARELISTSPROC)(HGLRC   hrcSrvShare, HGLRC   hrcSrvSource);
+typedef INT64 (GLAD_API_PTR *PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC   hdc, INT64   target_msc, INT64   divisor, INT64   remainder);
+typedef BOOL (GLAD_API_PTR *PFNWGLSWAPINTERVALEXTPROC)(int  interval);
+typedef BOOL (GLAD_API_PTR *PFNWGLSWAPLAYERBUFFERSPROC)(HDC   hdc, UINT   fuFlags);
+typedef INT64 (GLAD_API_PTR *PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC   hdc, int  fuPlanes, INT64   target_msc, INT64   divisor, INT64   remainder);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTBITMAPSPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTBITMAPSAPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTBITMAPSWPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTOUTLINESPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase, FLOAT   deviation, FLOAT   extrusion, int  format, LPGLYPHMETRICSFLOAT   lpgmf);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTOUTLINESAPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase, FLOAT   deviation, FLOAT   extrusion, int  format, LPGLYPHMETRICSFLOAT   lpgmf);
+typedef BOOL (GLAD_API_PTR *PFNWGLUSEFONTOUTLINESWPROC)(HDC   hDC, DWORD   first, DWORD   count, DWORD   listBase, FLOAT   deviation, FLOAT   extrusion, int  format, LPGLYPHMETRICSFLOAT   lpgmf);
+typedef BOOL (GLAD_API_PTR *PFNWGLWAITFORMSCOMLPROC)(HDC   hdc, INT64   target_msc, INT64   divisor, INT64   remainder, INT64  * ust, INT64  * msc, INT64  * sbc);
+typedef BOOL (GLAD_API_PTR *PFNWGLWAITFORSBCOMLPROC)(HDC   hdc, INT64   target_sbc, INT64  * ust, INT64  * msc, INT64  * sbc);
+
+GLAD_API_CALL PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+#define wglAllocateMemoryNV glad_wglAllocateMemoryNV
+GLAD_API_CALL PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+#define wglAssociateImageBufferEventsI3D glad_wglAssociateImageBufferEventsI3D
+GLAD_API_CALL PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D;
+#define wglBeginFrameTrackingI3D glad_wglBeginFrameTrackingI3D
+GLAD_API_CALL PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+#define wglBindDisplayColorTableEXT glad_wglBindDisplayColorTableEXT
+GLAD_API_CALL PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+#define wglBindSwapBarrierNV glad_wglBindSwapBarrierNV
+GLAD_API_CALL PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+#define wglBindTexImageARB glad_wglBindTexImageARB
+GLAD_API_CALL PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+#define wglBindVideoCaptureDeviceNV glad_wglBindVideoCaptureDeviceNV
+GLAD_API_CALL PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+#define wglBindVideoDeviceNV glad_wglBindVideoDeviceNV
+GLAD_API_CALL PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+#define wglBindVideoImageNV glad_wglBindVideoImageNV
+GLAD_API_CALL PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD;
+#define wglBlitContextFramebufferAMD glad_wglBlitContextFramebufferAMD
+GLAD_API_CALL PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+#define wglChoosePixelFormatARB glad_wglChoosePixelFormatARB
+GLAD_API_CALL PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+#define wglChoosePixelFormatEXT glad_wglChoosePixelFormatEXT
+GLAD_API_CALL PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+#define wglCopyImageSubDataNV glad_wglCopyImageSubDataNV
+GLAD_API_CALL PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+#define wglCreateAffinityDCNV glad_wglCreateAffinityDCNV
+GLAD_API_CALL PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD;
+#define wglCreateAssociatedContextAMD glad_wglCreateAssociatedContextAMD
+GLAD_API_CALL PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD;
+#define wglCreateAssociatedContextAttribsAMD glad_wglCreateAssociatedContextAttribsAMD
+GLAD_API_CALL PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+#define wglCreateBufferRegionARB glad_wglCreateBufferRegionARB
+GLAD_API_CALL PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+#define wglCreateContextAttribsARB glad_wglCreateContextAttribsARB
+GLAD_API_CALL PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+#define wglCreateDisplayColorTableEXT glad_wglCreateDisplayColorTableEXT
+GLAD_API_CALL PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+#define wglCreateImageBufferI3D glad_wglCreateImageBufferI3D
+GLAD_API_CALL PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+#define wglCreatePbufferARB glad_wglCreatePbufferARB
+GLAD_API_CALL PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+#define wglCreatePbufferEXT glad_wglCreatePbufferEXT
+GLAD_API_CALL PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+#define wglDXCloseDeviceNV glad_wglDXCloseDeviceNV
+GLAD_API_CALL PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+#define wglDXLockObjectsNV glad_wglDXLockObjectsNV
+GLAD_API_CALL PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+#define wglDXObjectAccessNV glad_wglDXObjectAccessNV
+GLAD_API_CALL PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+#define wglDXOpenDeviceNV glad_wglDXOpenDeviceNV
+GLAD_API_CALL PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+#define wglDXRegisterObjectNV glad_wglDXRegisterObjectNV
+GLAD_API_CALL PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+#define wglDXSetResourceShareHandleNV glad_wglDXSetResourceShareHandleNV
+GLAD_API_CALL PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+#define wglDXUnlockObjectsNV glad_wglDXUnlockObjectsNV
+GLAD_API_CALL PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+#define wglDXUnregisterObjectNV glad_wglDXUnregisterObjectNV
+GLAD_API_CALL PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+#define wglDelayBeforeSwapNV glad_wglDelayBeforeSwapNV
+GLAD_API_CALL PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD;
+#define wglDeleteAssociatedContextAMD glad_wglDeleteAssociatedContextAMD
+GLAD_API_CALL PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+#define wglDeleteBufferRegionARB glad_wglDeleteBufferRegionARB
+GLAD_API_CALL PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+#define wglDeleteDCNV glad_wglDeleteDCNV
+GLAD_API_CALL PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+#define wglDestroyDisplayColorTableEXT glad_wglDestroyDisplayColorTableEXT
+GLAD_API_CALL PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+#define wglDestroyImageBufferI3D glad_wglDestroyImageBufferI3D
+GLAD_API_CALL PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+#define wglDestroyPbufferARB glad_wglDestroyPbufferARB
+GLAD_API_CALL PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+#define wglDestroyPbufferEXT glad_wglDestroyPbufferEXT
+GLAD_API_CALL PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D;
+#define wglDisableFrameLockI3D glad_wglDisableFrameLockI3D
+GLAD_API_CALL PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D;
+#define wglDisableGenlockI3D glad_wglDisableGenlockI3D
+GLAD_API_CALL PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D;
+#define wglEnableFrameLockI3D glad_wglEnableFrameLockI3D
+GLAD_API_CALL PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D;
+#define wglEnableGenlockI3D glad_wglEnableGenlockI3D
+GLAD_API_CALL PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D;
+#define wglEndFrameTrackingI3D glad_wglEndFrameTrackingI3D
+GLAD_API_CALL PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+#define wglEnumGpuDevicesNV glad_wglEnumGpuDevicesNV
+GLAD_API_CALL PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+#define wglEnumGpusFromAffinityDCNV glad_wglEnumGpusFromAffinityDCNV
+GLAD_API_CALL PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+#define wglEnumGpusNV glad_wglEnumGpusNV
+GLAD_API_CALL PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+#define wglEnumerateVideoCaptureDevicesNV glad_wglEnumerateVideoCaptureDevicesNV
+GLAD_API_CALL PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+#define wglEnumerateVideoDevicesNV glad_wglEnumerateVideoDevicesNV
+GLAD_API_CALL PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+#define wglFreeMemoryNV glad_wglFreeMemoryNV
+GLAD_API_CALL PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D;
+#define wglGenlockSampleRateI3D glad_wglGenlockSampleRateI3D
+GLAD_API_CALL PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D;
+#define wglGenlockSourceDelayI3D glad_wglGenlockSourceDelayI3D
+GLAD_API_CALL PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D;
+#define wglGenlockSourceEdgeI3D glad_wglGenlockSourceEdgeI3D
+GLAD_API_CALL PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D;
+#define wglGenlockSourceI3D glad_wglGenlockSourceI3D
+GLAD_API_CALL PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD;
+#define wglGetContextGPUIDAMD glad_wglGetContextGPUIDAMD
+GLAD_API_CALL PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_wglGetCurrentAssociatedContextAMD;
+#define wglGetCurrentAssociatedContextAMD glad_wglGetCurrentAssociatedContextAMD
+GLAD_API_CALL PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+#define wglGetCurrentReadDCARB glad_wglGetCurrentReadDCARB
+GLAD_API_CALL PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+#define wglGetCurrentReadDCEXT glad_wglGetCurrentReadDCEXT
+GLAD_API_CALL PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+#define wglGetDigitalVideoParametersI3D glad_wglGetDigitalVideoParametersI3D
+GLAD_API_CALL PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+#define wglGetExtensionsStringARB glad_wglGetExtensionsStringARB
+GLAD_API_CALL PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;
+#define wglGetExtensionsStringEXT glad_wglGetExtensionsStringEXT
+GLAD_API_CALL PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D;
+#define wglGetFrameUsageI3D glad_wglGetFrameUsageI3D
+GLAD_API_CALL PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD;
+#define wglGetGPUIDsAMD glad_wglGetGPUIDsAMD
+GLAD_API_CALL PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD;
+#define wglGetGPUInfoAMD glad_wglGetGPUInfoAMD
+GLAD_API_CALL PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+#define wglGetGammaTableI3D glad_wglGetGammaTableI3D
+GLAD_API_CALL PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+#define wglGetGammaTableParametersI3D glad_wglGetGammaTableParametersI3D
+GLAD_API_CALL PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D;
+#define wglGetGenlockSampleRateI3D glad_wglGetGenlockSampleRateI3D
+GLAD_API_CALL PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D;
+#define wglGetGenlockSourceDelayI3D glad_wglGetGenlockSourceDelayI3D
+GLAD_API_CALL PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D;
+#define wglGetGenlockSourceEdgeI3D glad_wglGetGenlockSourceEdgeI3D
+GLAD_API_CALL PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D;
+#define wglGetGenlockSourceI3D glad_wglGetGenlockSourceI3D
+GLAD_API_CALL PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+#define wglGetMscRateOML glad_wglGetMscRateOML
+GLAD_API_CALL PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+#define wglGetPbufferDCARB glad_wglGetPbufferDCARB
+GLAD_API_CALL PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+#define wglGetPbufferDCEXT glad_wglGetPbufferDCEXT
+GLAD_API_CALL PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+#define wglGetPixelFormatAttribfvARB glad_wglGetPixelFormatAttribfvARB
+GLAD_API_CALL PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+#define wglGetPixelFormatAttribfvEXT glad_wglGetPixelFormatAttribfvEXT
+GLAD_API_CALL PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+#define wglGetPixelFormatAttribivARB glad_wglGetPixelFormatAttribivARB
+GLAD_API_CALL PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+#define wglGetPixelFormatAttribivEXT glad_wglGetPixelFormatAttribivEXT
+GLAD_API_CALL PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+#define wglGetSwapIntervalEXT glad_wglGetSwapIntervalEXT
+GLAD_API_CALL PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+#define wglGetSyncValuesOML glad_wglGetSyncValuesOML
+GLAD_API_CALL PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+#define wglGetVideoDeviceNV glad_wglGetVideoDeviceNV
+GLAD_API_CALL PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+#define wglGetVideoInfoNV glad_wglGetVideoInfoNV
+GLAD_API_CALL PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+#define wglIsEnabledFrameLockI3D glad_wglIsEnabledFrameLockI3D
+GLAD_API_CALL PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D;
+#define wglIsEnabledGenlockI3D glad_wglIsEnabledGenlockI3D
+GLAD_API_CALL PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+#define wglJoinSwapGroupNV glad_wglJoinSwapGroupNV
+GLAD_API_CALL PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+#define wglLoadDisplayColorTableEXT glad_wglLoadDisplayColorTableEXT
+GLAD_API_CALL PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+#define wglLockVideoCaptureDeviceNV glad_wglLockVideoCaptureDeviceNV
+GLAD_API_CALL PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_wglMakeAssociatedContextCurrentAMD;
+#define wglMakeAssociatedContextCurrentAMD glad_wglMakeAssociatedContextCurrentAMD
+GLAD_API_CALL PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+#define wglMakeContextCurrentARB glad_wglMakeContextCurrentARB
+GLAD_API_CALL PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+#define wglMakeContextCurrentEXT glad_wglMakeContextCurrentEXT
+GLAD_API_CALL PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+#define wglQueryCurrentContextNV glad_wglQueryCurrentContextNV
+GLAD_API_CALL PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+#define wglQueryFrameCountNV glad_wglQueryFrameCountNV
+GLAD_API_CALL PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+#define wglQueryFrameLockMasterI3D glad_wglQueryFrameLockMasterI3D
+GLAD_API_CALL PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+#define wglQueryFrameTrackingI3D glad_wglQueryFrameTrackingI3D
+GLAD_API_CALL PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D;
+#define wglQueryGenlockMaxSourceDelayI3D glad_wglQueryGenlockMaxSourceDelayI3D
+GLAD_API_CALL PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+#define wglQueryMaxSwapGroupsNV glad_wglQueryMaxSwapGroupsNV
+GLAD_API_CALL PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+#define wglQueryPbufferARB glad_wglQueryPbufferARB
+GLAD_API_CALL PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+#define wglQueryPbufferEXT glad_wglQueryPbufferEXT
+GLAD_API_CALL PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+#define wglQuerySwapGroupNV glad_wglQuerySwapGroupNV
+GLAD_API_CALL PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+#define wglQueryVideoCaptureDeviceNV glad_wglQueryVideoCaptureDeviceNV
+GLAD_API_CALL PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+#define wglReleaseImageBufferEventsI3D glad_wglReleaseImageBufferEventsI3D
+GLAD_API_CALL PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+#define wglReleasePbufferDCARB glad_wglReleasePbufferDCARB
+GLAD_API_CALL PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+#define wglReleasePbufferDCEXT glad_wglReleasePbufferDCEXT
+GLAD_API_CALL PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+#define wglReleaseTexImageARB glad_wglReleaseTexImageARB
+GLAD_API_CALL PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+#define wglReleaseVideoCaptureDeviceNV glad_wglReleaseVideoCaptureDeviceNV
+GLAD_API_CALL PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+#define wglReleaseVideoDeviceNV glad_wglReleaseVideoDeviceNV
+GLAD_API_CALL PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+#define wglReleaseVideoImageNV glad_wglReleaseVideoImageNV
+GLAD_API_CALL PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+#define wglResetFrameCountNV glad_wglResetFrameCountNV
+GLAD_API_CALL PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+#define wglRestoreBufferRegionARB glad_wglRestoreBufferRegionARB
+GLAD_API_CALL PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+#define wglSaveBufferRegionARB glad_wglSaveBufferRegionARB
+GLAD_API_CALL PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+#define wglSendPbufferToVideoNV glad_wglSendPbufferToVideoNV
+GLAD_API_CALL PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+#define wglSetDigitalVideoParametersI3D glad_wglSetDigitalVideoParametersI3D
+GLAD_API_CALL PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+#define wglSetGammaTableI3D glad_wglSetGammaTableI3D
+GLAD_API_CALL PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+#define wglSetGammaTableParametersI3D glad_wglSetGammaTableParametersI3D
+GLAD_API_CALL PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+#define wglSetPbufferAttribARB glad_wglSetPbufferAttribARB
+GLAD_API_CALL PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+#define wglSetStereoEmitterState3DL glad_wglSetStereoEmitterState3DL
+GLAD_API_CALL PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+#define wglSwapBuffersMscOML glad_wglSwapBuffersMscOML
+GLAD_API_CALL PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+#define wglSwapIntervalEXT glad_wglSwapIntervalEXT
+GLAD_API_CALL PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+#define wglSwapLayerBuffersMscOML glad_wglSwapLayerBuffersMscOML
+GLAD_API_CALL PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+#define wglWaitForMscOML glad_wglWaitForMscOML
+GLAD_API_CALL PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+#define wglWaitForSbcOML glad_wglWaitForSbcOML
+
+
+GLAD_API_CALL int gladLoadWGLUserPtr(HDC hdc, GLADuserptrloadfunc load, void *userptr);
+GLAD_API_CALL int gladLoadWGL(HDC hdc, GLADloadfunc load);
+
+
+
+
+#ifdef GLAD_WGL
+
+GLAD_API_CALL int gladLoaderLoadWGL(HDC hdc);
+
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+/* Source */
+#ifdef GLAD_WGL_IMPLEMENTATION
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+
+int GLAD_WGL_VERSION_1_0 = 0;
+int GLAD_WGL_3DFX_multisample = 0;
+int GLAD_WGL_3DL_stereo_control = 0;
+int GLAD_WGL_AMD_gpu_association = 0;
+int GLAD_WGL_ARB_buffer_region = 0;
+int GLAD_WGL_ARB_context_flush_control = 0;
+int GLAD_WGL_ARB_create_context = 0;
+int GLAD_WGL_ARB_create_context_no_error = 0;
+int GLAD_WGL_ARB_create_context_profile = 0;
+int GLAD_WGL_ARB_create_context_robustness = 0;
+int GLAD_WGL_ARB_extensions_string = 0;
+int GLAD_WGL_ARB_framebuffer_sRGB = 0;
+int GLAD_WGL_ARB_make_current_read = 0;
+int GLAD_WGL_ARB_multisample = 0;
+int GLAD_WGL_ARB_pbuffer = 0;
+int GLAD_WGL_ARB_pixel_format = 0;
+int GLAD_WGL_ARB_pixel_format_float = 0;
+int GLAD_WGL_ARB_render_texture = 0;
+int GLAD_WGL_ARB_robustness_application_isolation = 0;
+int GLAD_WGL_ARB_robustness_share_group_isolation = 0;
+int GLAD_WGL_ATI_pixel_format_float = 0;
+int GLAD_WGL_ATI_render_texture_rectangle = 0;
+int GLAD_WGL_EXT_colorspace = 0;
+int GLAD_WGL_EXT_create_context_es2_profile = 0;
+int GLAD_WGL_EXT_create_context_es_profile = 0;
+int GLAD_WGL_EXT_depth_float = 0;
+int GLAD_WGL_EXT_display_color_table = 0;
+int GLAD_WGL_EXT_extensions_string = 0;
+int GLAD_WGL_EXT_framebuffer_sRGB = 0;
+int GLAD_WGL_EXT_make_current_read = 0;
+int GLAD_WGL_EXT_multisample = 0;
+int GLAD_WGL_EXT_pbuffer = 0;
+int GLAD_WGL_EXT_pixel_format = 0;
+int GLAD_WGL_EXT_pixel_format_packed_float = 0;
+int GLAD_WGL_EXT_swap_control = 0;
+int GLAD_WGL_EXT_swap_control_tear = 0;
+int GLAD_WGL_I3D_digital_video_control = 0;
+int GLAD_WGL_I3D_gamma = 0;
+int GLAD_WGL_I3D_genlock = 0;
+int GLAD_WGL_I3D_image_buffer = 0;
+int GLAD_WGL_I3D_swap_frame_lock = 0;
+int GLAD_WGL_I3D_swap_frame_usage = 0;
+int GLAD_WGL_NV_DX_interop = 0;
+int GLAD_WGL_NV_DX_interop2 = 0;
+int GLAD_WGL_NV_copy_image = 0;
+int GLAD_WGL_NV_delay_before_swap = 0;
+int GLAD_WGL_NV_float_buffer = 0;
+int GLAD_WGL_NV_gpu_affinity = 0;
+int GLAD_WGL_NV_multisample_coverage = 0;
+int GLAD_WGL_NV_present_video = 0;
+int GLAD_WGL_NV_render_depth_texture = 0;
+int GLAD_WGL_NV_render_texture_rectangle = 0;
+int GLAD_WGL_NV_swap_group = 0;
+int GLAD_WGL_NV_vertex_array_range = 0;
+int GLAD_WGL_NV_video_capture = 0;
+int GLAD_WGL_NV_video_output = 0;
+int GLAD_WGL_OML_sync_control = 0;
+
+
+
+PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D;
+PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD;
+PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD;
+PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD;
+PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD;
+PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D;
+PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D;
+PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D;
+PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D;
+PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D;
+PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D;
+PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D;
+PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D;
+PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D;
+PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD;
+PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_wglGetCurrentAssociatedContextAMD;
+PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;
+PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D;
+PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD;
+PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD;
+PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D;
+PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D;
+PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D;
+PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D;
+PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D;
+PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_wglMakeAssociatedContextCurrentAMD;
+PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D;
+PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+
+
+static void glad_wgl_load_WGL_3DL_stereo_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_3DL_stereo_control) return;
+    glad_wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC) load("wglSetStereoEmitterState3DL", userptr);
+}
+static void glad_wgl_load_WGL_AMD_gpu_association(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_AMD_gpu_association) return;
+    glad_wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) load("wglBlitContextFramebufferAMD", userptr);
+    glad_wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) load("wglCreateAssociatedContextAMD", userptr);
+    glad_wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) load("wglCreateAssociatedContextAttribsAMD", userptr);
+    glad_wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) load("wglDeleteAssociatedContextAMD", userptr);
+    glad_wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC) load("wglGetContextGPUIDAMD", userptr);
+    glad_wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) load("wglGetCurrentAssociatedContextAMD", userptr);
+    glad_wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC) load("wglGetGPUIDsAMD", userptr);
+    glad_wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC) load("wglGetGPUInfoAMD", userptr);
+    glad_wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) load("wglMakeAssociatedContextCurrentAMD", userptr);
+}
+static void glad_wgl_load_WGL_ARB_buffer_region(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_buffer_region) return;
+    glad_wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC) load("wglCreateBufferRegionARB", userptr);
+    glad_wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC) load("wglDeleteBufferRegionARB", userptr);
+    glad_wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC) load("wglRestoreBufferRegionARB", userptr);
+    glad_wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC) load("wglSaveBufferRegionARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_create_context(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_create_context) return;
+    glad_wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) load("wglCreateContextAttribsARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_extensions_string(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_extensions_string) return;
+    glad_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) load("wglGetExtensionsStringARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_make_current_read(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_make_current_read) return;
+    glad_wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC) load("wglGetCurrentReadDCARB", userptr);
+    glad_wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC) load("wglMakeContextCurrentARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_pbuffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_pbuffer) return;
+    glad_wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) load("wglCreatePbufferARB", userptr);
+    glad_wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC) load("wglDestroyPbufferARB", userptr);
+    glad_wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) load("wglGetPbufferDCARB", userptr);
+    glad_wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC) load("wglQueryPbufferARB", userptr);
+    glad_wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) load("wglReleasePbufferDCARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_pixel_format(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_pixel_format) return;
+    glad_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) load("wglChoosePixelFormatARB", userptr);
+    glad_wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC) load("wglGetPixelFormatAttribfvARB", userptr);
+    glad_wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC) load("wglGetPixelFormatAttribivARB", userptr);
+}
+static void glad_wgl_load_WGL_ARB_render_texture(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_render_texture) return;
+    glad_wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) load("wglBindTexImageARB", userptr);
+    glad_wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC) load("wglReleaseTexImageARB", userptr);
+    glad_wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC) load("wglSetPbufferAttribARB", userptr);
+}
+static void glad_wgl_load_WGL_EXT_display_color_table(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_display_color_table) return;
+    glad_wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) load("wglBindDisplayColorTableEXT", userptr);
+    glad_wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) load("wglCreateDisplayColorTableEXT", userptr);
+    glad_wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) load("wglDestroyDisplayColorTableEXT", userptr);
+    glad_wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) load("wglLoadDisplayColorTableEXT", userptr);
+}
+static void glad_wgl_load_WGL_EXT_extensions_string(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_extensions_string) return;
+    glad_wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) load("wglGetExtensionsStringEXT", userptr);
+}
+static void glad_wgl_load_WGL_EXT_make_current_read(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_make_current_read) return;
+    glad_wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC) load("wglGetCurrentReadDCEXT", userptr);
+    glad_wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC) load("wglMakeContextCurrentEXT", userptr);
+}
+static void glad_wgl_load_WGL_EXT_pbuffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_pbuffer) return;
+    glad_wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC) load("wglCreatePbufferEXT", userptr);
+    glad_wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC) load("wglDestroyPbufferEXT", userptr);
+    glad_wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC) load("wglGetPbufferDCEXT", userptr);
+    glad_wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC) load("wglQueryPbufferEXT", userptr);
+    glad_wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC) load("wglReleasePbufferDCEXT", userptr);
+}
+static void glad_wgl_load_WGL_EXT_pixel_format(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_pixel_format) return;
+    glad_wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC) load("wglChoosePixelFormatEXT", userptr);
+    glad_wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) load("wglGetPixelFormatAttribfvEXT", userptr);
+    glad_wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) load("wglGetPixelFormatAttribivEXT", userptr);
+}
+static void glad_wgl_load_WGL_EXT_swap_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_swap_control) return;
+    glad_wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC) load("wglGetSwapIntervalEXT", userptr);
+    glad_wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) load("wglSwapIntervalEXT", userptr);
+}
+static void glad_wgl_load_WGL_I3D_digital_video_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_digital_video_control) return;
+    glad_wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) load("wglGetDigitalVideoParametersI3D", userptr);
+    glad_wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) load("wglSetDigitalVideoParametersI3D", userptr);
+}
+static void glad_wgl_load_WGL_I3D_gamma(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_gamma) return;
+    glad_wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC) load("wglGetGammaTableI3D", userptr);
+    glad_wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) load("wglGetGammaTableParametersI3D", userptr);
+    glad_wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC) load("wglSetGammaTableI3D", userptr);
+    glad_wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) load("wglSetGammaTableParametersI3D", userptr);
+}
+static void glad_wgl_load_WGL_I3D_genlock(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_genlock) return;
+    glad_wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC) load("wglDisableGenlockI3D", userptr);
+    glad_wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC) load("wglEnableGenlockI3D", userptr);
+    glad_wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC) load("wglGenlockSampleRateI3D", userptr);
+    glad_wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC) load("wglGenlockSourceDelayI3D", userptr);
+    glad_wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC) load("wglGenlockSourceEdgeI3D", userptr);
+    glad_wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC) load("wglGenlockSourceI3D", userptr);
+    glad_wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC) load("wglGetGenlockSampleRateI3D", userptr);
+    glad_wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) load("wglGetGenlockSourceDelayI3D", userptr);
+    glad_wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) load("wglGetGenlockSourceEdgeI3D", userptr);
+    glad_wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC) load("wglGetGenlockSourceI3D", userptr);
+    glad_wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC) load("wglIsEnabledGenlockI3D", userptr);
+    glad_wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) load("wglQueryGenlockMaxSourceDelayI3D", userptr);
+}
+static void glad_wgl_load_WGL_I3D_image_buffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_image_buffer) return;
+    glad_wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) load("wglAssociateImageBufferEventsI3D", userptr);
+    glad_wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC) load("wglCreateImageBufferI3D", userptr);
+    glad_wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC) load("wglDestroyImageBufferI3D", userptr);
+    glad_wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) load("wglReleaseImageBufferEventsI3D", userptr);
+}
+static void glad_wgl_load_WGL_I3D_swap_frame_lock(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_swap_frame_lock) return;
+    glad_wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC) load("wglDisableFrameLockI3D", userptr);
+    glad_wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC) load("wglEnableFrameLockI3D", userptr);
+    glad_wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC) load("wglIsEnabledFrameLockI3D", userptr);
+    glad_wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC) load("wglQueryFrameLockMasterI3D", userptr);
+}
+static void glad_wgl_load_WGL_I3D_swap_frame_usage(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_swap_frame_usage) return;
+    glad_wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC) load("wglBeginFrameTrackingI3D", userptr);
+    glad_wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC) load("wglEndFrameTrackingI3D", userptr);
+    glad_wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC) load("wglGetFrameUsageI3D", userptr);
+    glad_wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC) load("wglQueryFrameTrackingI3D", userptr);
+}
+static void glad_wgl_load_WGL_NV_DX_interop(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_DX_interop) return;
+    glad_wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC) load("wglDXCloseDeviceNV", userptr);
+    glad_wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC) load("wglDXLockObjectsNV", userptr);
+    glad_wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC) load("wglDXObjectAccessNV", userptr);
+    glad_wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC) load("wglDXOpenDeviceNV", userptr);
+    glad_wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC) load("wglDXRegisterObjectNV", userptr);
+    glad_wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC) load("wglDXSetResourceShareHandleNV", userptr);
+    glad_wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC) load("wglDXUnlockObjectsNV", userptr);
+    glad_wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC) load("wglDXUnregisterObjectNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_copy_image(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_copy_image) return;
+    glad_wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC) load("wglCopyImageSubDataNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_delay_before_swap(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_delay_before_swap) return;
+    glad_wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC) load("wglDelayBeforeSwapNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_gpu_affinity(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_gpu_affinity) return;
+    glad_wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC) load("wglCreateAffinityDCNV", userptr);
+    glad_wglDeleteDCNV = (PFNWGLDELETEDCNVPROC) load("wglDeleteDCNV", userptr);
+    glad_wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC) load("wglEnumGpuDevicesNV", userptr);
+    glad_wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) load("wglEnumGpusFromAffinityDCNV", userptr);
+    glad_wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC) load("wglEnumGpusNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_present_video(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_present_video) return;
+    glad_wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC) load("wglBindVideoDeviceNV", userptr);
+    glad_wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC) load("wglEnumerateVideoDevicesNV", userptr);
+    glad_wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC) load("wglQueryCurrentContextNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_swap_group(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_swap_group) return;
+    glad_wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC) load("wglBindSwapBarrierNV", userptr);
+    glad_wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC) load("wglJoinSwapGroupNV", userptr);
+    glad_wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC) load("wglQueryFrameCountNV", userptr);
+    glad_wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC) load("wglQueryMaxSwapGroupsNV", userptr);
+    glad_wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC) load("wglQuerySwapGroupNV", userptr);
+    glad_wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC) load("wglResetFrameCountNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_vertex_array_range(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_vertex_array_range) return;
+    glad_wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC) load("wglAllocateMemoryNV", userptr);
+    glad_wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC) load("wglFreeMemoryNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_video_capture(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_video_capture) return;
+    glad_wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) load("wglBindVideoCaptureDeviceNV", userptr);
+    glad_wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) load("wglEnumerateVideoCaptureDevicesNV", userptr);
+    glad_wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) load("wglLockVideoCaptureDeviceNV", userptr);
+    glad_wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) load("wglQueryVideoCaptureDeviceNV", userptr);
+    glad_wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) load("wglReleaseVideoCaptureDeviceNV", userptr);
+}
+static void glad_wgl_load_WGL_NV_video_output(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_video_output) return;
+    glad_wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC) load("wglBindVideoImageNV", userptr);
+    glad_wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC) load("wglGetVideoDeviceNV", userptr);
+    glad_wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC) load("wglGetVideoInfoNV", userptr);
+    glad_wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC) load("wglReleaseVideoDeviceNV", userptr);
+    glad_wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC) load("wglReleaseVideoImageNV", userptr);
+    glad_wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC) load("wglSendPbufferToVideoNV", userptr);
+}
+static void glad_wgl_load_WGL_OML_sync_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_OML_sync_control) return;
+    glad_wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC) load("wglGetMscRateOML", userptr);
+    glad_wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC) load("wglGetSyncValuesOML", userptr);
+    glad_wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC) load("wglSwapBuffersMscOML", userptr);
+    glad_wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) load("wglSwapLayerBuffersMscOML", userptr);
+    glad_wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC) load("wglWaitForMscOML", userptr);
+    glad_wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC) load("wglWaitForSbcOML", userptr);
+}
+
+
+
+static int glad_wgl_has_extension(HDC hdc, const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(wglGetExtensionsStringEXT == NULL && wglGetExtensionsStringARB == NULL)
+        return 0;
+
+    if(wglGetExtensionsStringARB == NULL || hdc == INVALID_HANDLE_VALUE)
+        extensions = wglGetExtensionsStringEXT();
+    else
+        extensions = wglGetExtensionsStringARB(hdc);
+
+    if(extensions == NULL || ext == NULL)
+        return 0;
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\0'))
+        {
+            return 1;
+        }
+        extensions = terminator;
+    }
+
+    return 0;
+}
+
+static GLADapiproc glad_wgl_get_proc_from_userptr(const char* name, void *userptr) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_wgl_find_extensions_wgl(HDC hdc) {
+    GLAD_WGL_3DFX_multisample = glad_wgl_has_extension(hdc, "WGL_3DFX_multisample");
+    GLAD_WGL_3DL_stereo_control = glad_wgl_has_extension(hdc, "WGL_3DL_stereo_control");
+    GLAD_WGL_AMD_gpu_association = glad_wgl_has_extension(hdc, "WGL_AMD_gpu_association");
+    GLAD_WGL_ARB_buffer_region = glad_wgl_has_extension(hdc, "WGL_ARB_buffer_region");
+    GLAD_WGL_ARB_context_flush_control = glad_wgl_has_extension(hdc, "WGL_ARB_context_flush_control");
+    GLAD_WGL_ARB_create_context = glad_wgl_has_extension(hdc, "WGL_ARB_create_context");
+    GLAD_WGL_ARB_create_context_no_error = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_no_error");
+    GLAD_WGL_ARB_create_context_profile = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_profile");
+    GLAD_WGL_ARB_create_context_robustness = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_robustness");
+    GLAD_WGL_ARB_extensions_string = glad_wgl_has_extension(hdc, "WGL_ARB_extensions_string");
+    GLAD_WGL_ARB_framebuffer_sRGB = glad_wgl_has_extension(hdc, "WGL_ARB_framebuffer_sRGB");
+    GLAD_WGL_ARB_make_current_read = glad_wgl_has_extension(hdc, "WGL_ARB_make_current_read");
+    GLAD_WGL_ARB_multisample = glad_wgl_has_extension(hdc, "WGL_ARB_multisample");
+    GLAD_WGL_ARB_pbuffer = glad_wgl_has_extension(hdc, "WGL_ARB_pbuffer");
+    GLAD_WGL_ARB_pixel_format = glad_wgl_has_extension(hdc, "WGL_ARB_pixel_format");
+    GLAD_WGL_ARB_pixel_format_float = glad_wgl_has_extension(hdc, "WGL_ARB_pixel_format_float");
+    GLAD_WGL_ARB_render_texture = glad_wgl_has_extension(hdc, "WGL_ARB_render_texture");
+    GLAD_WGL_ARB_robustness_application_isolation = glad_wgl_has_extension(hdc, "WGL_ARB_robustness_application_isolation");
+    GLAD_WGL_ARB_robustness_share_group_isolation = glad_wgl_has_extension(hdc, "WGL_ARB_robustness_share_group_isolation");
+    GLAD_WGL_ATI_pixel_format_float = glad_wgl_has_extension(hdc, "WGL_ATI_pixel_format_float");
+    GLAD_WGL_ATI_render_texture_rectangle = glad_wgl_has_extension(hdc, "WGL_ATI_render_texture_rectangle");
+    GLAD_WGL_EXT_colorspace = glad_wgl_has_extension(hdc, "WGL_EXT_colorspace");
+    GLAD_WGL_EXT_create_context_es2_profile = glad_wgl_has_extension(hdc, "WGL_EXT_create_context_es2_profile");
+    GLAD_WGL_EXT_create_context_es_profile = glad_wgl_has_extension(hdc, "WGL_EXT_create_context_es_profile");
+    GLAD_WGL_EXT_depth_float = glad_wgl_has_extension(hdc, "WGL_EXT_depth_float");
+    GLAD_WGL_EXT_display_color_table = glad_wgl_has_extension(hdc, "WGL_EXT_display_color_table");
+    GLAD_WGL_EXT_extensions_string = glad_wgl_has_extension(hdc, "WGL_EXT_extensions_string");
+    GLAD_WGL_EXT_framebuffer_sRGB = glad_wgl_has_extension(hdc, "WGL_EXT_framebuffer_sRGB");
+    GLAD_WGL_EXT_make_current_read = glad_wgl_has_extension(hdc, "WGL_EXT_make_current_read");
+    GLAD_WGL_EXT_multisample = glad_wgl_has_extension(hdc, "WGL_EXT_multisample");
+    GLAD_WGL_EXT_pbuffer = glad_wgl_has_extension(hdc, "WGL_EXT_pbuffer");
+    GLAD_WGL_EXT_pixel_format = glad_wgl_has_extension(hdc, "WGL_EXT_pixel_format");
+    GLAD_WGL_EXT_pixel_format_packed_float = glad_wgl_has_extension(hdc, "WGL_EXT_pixel_format_packed_float");
+    GLAD_WGL_EXT_swap_control = glad_wgl_has_extension(hdc, "WGL_EXT_swap_control");
+    GLAD_WGL_EXT_swap_control_tear = glad_wgl_has_extension(hdc, "WGL_EXT_swap_control_tear");
+    GLAD_WGL_I3D_digital_video_control = glad_wgl_has_extension(hdc, "WGL_I3D_digital_video_control");
+    GLAD_WGL_I3D_gamma = glad_wgl_has_extension(hdc, "WGL_I3D_gamma");
+    GLAD_WGL_I3D_genlock = glad_wgl_has_extension(hdc, "WGL_I3D_genlock");
+    GLAD_WGL_I3D_image_buffer = glad_wgl_has_extension(hdc, "WGL_I3D_image_buffer");
+    GLAD_WGL_I3D_swap_frame_lock = glad_wgl_has_extension(hdc, "WGL_I3D_swap_frame_lock");
+    GLAD_WGL_I3D_swap_frame_usage = glad_wgl_has_extension(hdc, "WGL_I3D_swap_frame_usage");
+    GLAD_WGL_NV_DX_interop = glad_wgl_has_extension(hdc, "WGL_NV_DX_interop");
+    GLAD_WGL_NV_DX_interop2 = glad_wgl_has_extension(hdc, "WGL_NV_DX_interop2");
+    GLAD_WGL_NV_copy_image = glad_wgl_has_extension(hdc, "WGL_NV_copy_image");
+    GLAD_WGL_NV_delay_before_swap = glad_wgl_has_extension(hdc, "WGL_NV_delay_before_swap");
+    GLAD_WGL_NV_float_buffer = glad_wgl_has_extension(hdc, "WGL_NV_float_buffer");
+    GLAD_WGL_NV_gpu_affinity = glad_wgl_has_extension(hdc, "WGL_NV_gpu_affinity");
+    GLAD_WGL_NV_multisample_coverage = glad_wgl_has_extension(hdc, "WGL_NV_multisample_coverage");
+    GLAD_WGL_NV_present_video = glad_wgl_has_extension(hdc, "WGL_NV_present_video");
+    GLAD_WGL_NV_render_depth_texture = glad_wgl_has_extension(hdc, "WGL_NV_render_depth_texture");
+    GLAD_WGL_NV_render_texture_rectangle = glad_wgl_has_extension(hdc, "WGL_NV_render_texture_rectangle");
+    GLAD_WGL_NV_swap_group = glad_wgl_has_extension(hdc, "WGL_NV_swap_group");
+    GLAD_WGL_NV_vertex_array_range = glad_wgl_has_extension(hdc, "WGL_NV_vertex_array_range");
+    GLAD_WGL_NV_video_capture = glad_wgl_has_extension(hdc, "WGL_NV_video_capture");
+    GLAD_WGL_NV_video_output = glad_wgl_has_extension(hdc, "WGL_NV_video_output");
+    GLAD_WGL_OML_sync_control = glad_wgl_has_extension(hdc, "WGL_OML_sync_control");
+    return 1;
+}
+
+static int glad_wgl_find_core_wgl(void) {
+    int major = 1, minor = 0;
+    GLAD_WGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadWGLUserPtr(HDC hdc, GLADuserptrloadfunc load, void *userptr) {
+    int version;
+    wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) load("wglGetExtensionsStringARB", userptr);
+    wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) load("wglGetExtensionsStringEXT", userptr);
+    if(wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return 0;
+    version = glad_wgl_find_core_wgl();
+
+
+    if (!glad_wgl_find_extensions_wgl(hdc)) return 0;
+    glad_wgl_load_WGL_3DL_stereo_control(load, userptr);
+    glad_wgl_load_WGL_AMD_gpu_association(load, userptr);
+    glad_wgl_load_WGL_ARB_buffer_region(load, userptr);
+    glad_wgl_load_WGL_ARB_create_context(load, userptr);
+    glad_wgl_load_WGL_ARB_extensions_string(load, userptr);
+    glad_wgl_load_WGL_ARB_make_current_read(load, userptr);
+    glad_wgl_load_WGL_ARB_pbuffer(load, userptr);
+    glad_wgl_load_WGL_ARB_pixel_format(load, userptr);
+    glad_wgl_load_WGL_ARB_render_texture(load, userptr);
+    glad_wgl_load_WGL_EXT_display_color_table(load, userptr);
+    glad_wgl_load_WGL_EXT_extensions_string(load, userptr);
+    glad_wgl_load_WGL_EXT_make_current_read(load, userptr);
+    glad_wgl_load_WGL_EXT_pbuffer(load, userptr);
+    glad_wgl_load_WGL_EXT_pixel_format(load, userptr);
+    glad_wgl_load_WGL_EXT_swap_control(load, userptr);
+    glad_wgl_load_WGL_I3D_digital_video_control(load, userptr);
+    glad_wgl_load_WGL_I3D_gamma(load, userptr);
+    glad_wgl_load_WGL_I3D_genlock(load, userptr);
+    glad_wgl_load_WGL_I3D_image_buffer(load, userptr);
+    glad_wgl_load_WGL_I3D_swap_frame_lock(load, userptr);
+    glad_wgl_load_WGL_I3D_swap_frame_usage(load, userptr);
+    glad_wgl_load_WGL_NV_DX_interop(load, userptr);
+    glad_wgl_load_WGL_NV_copy_image(load, userptr);
+    glad_wgl_load_WGL_NV_delay_before_swap(load, userptr);
+    glad_wgl_load_WGL_NV_gpu_affinity(load, userptr);
+    glad_wgl_load_WGL_NV_present_video(load, userptr);
+    glad_wgl_load_WGL_NV_swap_group(load, userptr);
+    glad_wgl_load_WGL_NV_vertex_array_range(load, userptr);
+    glad_wgl_load_WGL_NV_video_capture(load, userptr);
+    glad_wgl_load_WGL_NV_video_output(load, userptr);
+    glad_wgl_load_WGL_OML_sync_control(load, userptr);
+
+    return version;
+}
+
+int gladLoadWGL(HDC hdc, GLADloadfunc load) {
+    return gladLoadWGLUserPtr(hdc, glad_wgl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+#ifdef GLAD_WGL
+
+int gladLoaderLoadWGL(HDC hdc) {
+    return gladLoadWGLUserPtr(hdc, glad_wgl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) wglGetProcAddress);
+}
+
+#endif /* GLAD_WGL */
+
+#endif /* GLAD_WGL_IMPLEMENTATION */
+

+ 43 - 0
package-system/googlebenchmark/FindGoogleBenchmark.cmake.template

@@ -0,0 +1,43 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+# this file actually ingests the library and defines targets.
+
+set(TARGET_WITH_NAMESPACE "3rdParty::GoogleBenchmark")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+
+set(GOOGLEBENCHMARK_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/googlebenchmark/include)
+set(GOOGLEBENCHMARK_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/googlebenchmark/lib)
+
+set(GOOGLEBENCHMARK_COMPILE_DEFINITIONS
+    HAVE_BENCHMARK
+${CUSTOM_ADDITIONAL_COMPILE_DEFINITIONS})
+
+
+set(GOOGLEBENCHMARK_LIBS_DEBUG   $${GOOGLEBENCHMARK_LIBS_DIR}/Debug/$${CMAKE_STATIC_LIBRARY_PREFIX}benchmark$${CMAKE_STATIC_LIBRARY_SUFFIX})
+set(GOOGLEBENCHMARK_LIBS_RELEASE $${GOOGLEBENCHMARK_LIBS_DIR}/Release/$${CMAKE_STATIC_LIBRARY_PREFIX}benchmark$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+set(GOOGLEBENCHMARK_LIBRARY
+    "$$<$$<CONFIG:profile>:$${GOOGLEBENCHMARK_LIBS_RELEASE}>"
+    "$$<$$<CONFIG:Release>:$${GOOGLEBENCHMARK_LIBS_RELEASE}>"
+    "$$<$$<CONFIG:Debug>:$${GOOGLEBENCHMARK_LIBS_DEBUG}>"
+${CUSTOM_ADDITIONAL_LIBRARIES})
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_INCLUDE_DIR})
+
+target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_LIBRARY})
+
+target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_COMPILE_DEFINITIONS})
+
+set(GOOGLETEST_GTEST_FOUND True)
+

+ 38 - 0
package-system/googlebenchmark/FindGoogleBenchmarkRelOnly.cmake.template

@@ -0,0 +1,38 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+# this file actually ingests the library and defines targets.
+
+set(TARGET_WITH_NAMESPACE "3rdParty::GoogleBenchmark")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+
+set(GOOGLEBENCHMARK_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/googlebenchmark/include)
+set(GOOGLEBENCHMARK_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/googlebenchmark/lib)
+
+set(GOOGLEBENCHMARK_COMPILE_DEFINITIONS
+    HAVE_BENCHMARK
+${CUSTOM_ADDITIONAL_COMPILE_DEFINITIONS})
+
+
+set(GOOGLEBENCHMARK_LIBRARY
+    $${GOOGLEBENCHMARK_LIBS_DIR}/Release/$${CMAKE_STATIC_LIBRARY_PREFIX}benchmark$${CMAKE_STATIC_LIBRARY_SUFFIX}
+${CUSTOM_ADDITIONAL_LIBRARIES})
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_INCLUDE_DIR})
+
+target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_LIBRARY})
+
+target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLEBENCHMARK_COMPILE_DEFINITIONS})
+
+set(GOOGLETEST_GTEST_FOUND True)
+

+ 250 - 0
package-system/googlebenchmark/benchmark-1.5.0.patch

@@ -0,0 +1,250 @@
+diff -N -a -u -r benchmark-1.5.0.orig/src/benchmark.cc benchmark-1.5.0/src/benchmark.cc
+--- benchmark-1.5.0.orig/src/benchmark.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/benchmark.cc	2020-10-14 22:05:36.383669200 -0500
+@@ -18,7 +18,7 @@
+ #include "internal_macros.h"
+ 
+ #ifndef BENCHMARK_OS_WINDOWS
+-#ifndef BENCHMARK_OS_FUCHSIA
++#if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_SYS_RESOURCE_H_UNSUPPORTED)
+ #include <sys/resource.h>
+ #endif
+ #include <sys/time.h>
+diff -N -a -u -r benchmark-1.5.0.orig/src/benchmark_register.cc benchmark-1.5.0/src/benchmark_register.cc
+--- benchmark-1.5.0.orig/src/benchmark_register.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/benchmark_register.cc	2020-10-14 22:06:56.901076900 -0500
+@@ -15,7 +15,7 @@
+ #include "benchmark_register.h"
+ 
+ #ifndef BENCHMARK_OS_WINDOWS
+-#ifndef BENCHMARK_OS_FUCHSIA
++#if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_SYS_RESOURCE_H_UNSUPPORTED)
+ #include <sys/resource.h>
+ #endif
+ #include <sys/time.h>
+diff -N -a -u -r benchmark-1.5.0.orig/src/benchmark_runner.cc benchmark-1.5.0/src/benchmark_runner.cc
+--- benchmark-1.5.0.orig/src/benchmark_runner.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/benchmark_runner.cc	2020-10-14 22:07:01.282622200 -0500
+@@ -18,7 +18,7 @@
+ #include "internal_macros.h"
+ 
+ #ifndef BENCHMARK_OS_WINDOWS
+-#ifndef BENCHMARK_OS_FUCHSIA
++#if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_SYS_RESOURCE_H_UNSUPPORTED)
+ #include <sys/resource.h>
+ #endif
+ #include <sys/time.h>
+diff -N -a -u -r benchmark-1.5.0.orig/src/colorprint.cc benchmark-1.5.0/src/colorprint.cc
+--- benchmark-1.5.0.orig/src/colorprint.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/colorprint.cc	2020-10-14 22:07:43.727853800 -0500
+@@ -33,14 +33,14 @@
+ 
+ namespace benchmark {
+ namespace {
+-#ifdef BENCHMARK_OS_WINDOWS
++#if defined(BENCHMARK_OS_WINDOWS) && !defined(BENCHMARK_USE_ANSI_COLOR_MODE)
+ typedef WORD PlatformColorCode;
+ #else
+ typedef const char* PlatformColorCode;
+ #endif
+ 
+ PlatformColorCode GetPlatformColorCode(LogColor color) {
+-#ifdef BENCHMARK_OS_WINDOWS
++#if defined(BENCHMARK_OS_WINDOWS) && !defined(BENCHMARK_USE_ANSI_COLOR_MODE)
+   switch (color) {
+     case COLOR_RED:
+       return FOREGROUND_RED;
+@@ -127,7 +127,7 @@
+ 
+ void ColorPrintf(std::ostream& out, LogColor color, const char* fmt,
+                  va_list args) {
+-#ifdef BENCHMARK_OS_WINDOWS
++#if defined(BENCHMARK_OS_WINDOWS) && !defined(BENCHMARK_USE_ANSI_COLOR_MODE)
+   ((void)out);  // suppress unused warning
+ 
+   const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+diff -N -a -u -r benchmark-1.5.0.orig/src/commandlineflags.cc benchmark-1.5.0/src/commandlineflags.cc
+--- benchmark-1.5.0.orig/src/commandlineflags.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/commandlineflags.cc	2020-10-14 22:09:39.353104100 -0500
+@@ -13,7 +13,7 @@
+ // limitations under the License.
+ 
+ #include "commandlineflags.h"
+-
++#include "internal_macros.h"
+ #include <cctype>
+ #include <cstdlib>
+ #include <cstring>
+diff -N -a -u -r benchmark-1.5.0.orig/src/internal_macros.h benchmark-1.5.0/src/internal_macros.h
+--- benchmark-1.5.0.orig/src/internal_macros.h	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/internal_macros.h	2020-10-14 22:09:41.520871700 -0500
+@@ -89,6 +89,17 @@
+   #define BENCHMARK_MAYBE_UNUSED
+ #endif
+ 
++#ifdef BENCHMARK_ISATTY_UNSUPPORTED
++inline int isatty(int) {
++  return 0;
++}
++#endif
++
++#ifdef BENCHMARK_GETENV_UNSUPPORTED
++inline const char* getenv(const char*) {
++  return nullptr;
++}
++#endif
+ // clang-format on
+ 
+ #endif  // BENCHMARK_INTERNAL_MACROS_H_
+diff -N -a -u -r benchmark-1.5.0.orig/src/sysinfo.cc benchmark-1.5.0/src/sysinfo.cc
+--- benchmark-1.5.0.orig/src/sysinfo.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/sysinfo.cc	2020-10-14 22:56:44.702431200 -0500
+@@ -22,14 +22,14 @@
+ #include <codecvt>
+ #else
+ #include <fcntl.h>
+-#ifndef BENCHMARK_OS_FUCHSIA
++#if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_SYS_RESOURCE_H_UNSUPPORTED)
+ #include <sys/resource.h>
+ #endif
+ #include <sys/time.h>
+ #include <sys/types.h>  // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
+ #include <unistd.h>
+-#if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX || \
+-    defined BENCHMARK_OS_NETBSD || defined BENCHMARK_OS_OPENBSD
++#if (defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX || \
++    defined BENCHMARK_OS_NETBSD || defined BENCHMARK_OS_OPENBSD) && !defined(BENCHMARK_SYS_SYSCTL_H_UNSUPPORTED)
+ #define BENCHMARK_HAS_SYSCTL
+ #include <sys/sysctl.h>
+ #endif
+@@ -316,6 +316,7 @@
+ #elif defined(BENCHMARK_OS_WINDOWS)
+ std::vector<CPUInfo::CacheInfo> GetCacheSizesWindows() {
+   std::vector<CPUInfo::CacheInfo> res;
++#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY != WINAPI_FAMILY_TV_TITLE
+   DWORD buffer_size = 0;
+   using PInfo = SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
+   using CInfo = CACHE_DESCRIPTOR;
+@@ -360,6 +361,7 @@
+     }
+     res.push_back(C);
+   }
++#endif
+   return res;
+ }
+ #elif BENCHMARK_OS_QNX
+@@ -411,7 +413,9 @@
+ }
+ 
+ std::string GetSystemName() {
+-#if defined(BENCHMARK_OS_WINDOWS)
++#if defined(BENCHMARK_SYSTEM_NAME)
++  return { BENCHMARK_SYSTEM_NAME };
++#elif defined(BENCHMARK_OS_WINDOWS)
+   std::string str;
+   const unsigned COUNT = MAX_COMPUTERNAME_LENGTH+1;
+   TCHAR  hostname[COUNT] = {'\0'};
+@@ -434,10 +438,14 @@
+ #elif defined(BENCHMARK_OS_QNX)
+ #define HOST_NAME_MAX 154
+ #endif
++#if !defined(BENCHMARK_SYS_SYSCTL_H_UNSUPPORTED)
+   char hostname[HOST_NAME_MAX];
+   int retVal = gethostname(hostname, HOST_NAME_MAX);
+   if (retVal != 0) return std::string("");
+   return std::string(hostname);
++#else
++  return {};
++#endif
+ #endif // Catch-all POSIX block.
+ }
+ 
+@@ -610,11 +618,15 @@
+   // In NT, read MHz from the registry. If we fail to do so or we're in win9x
+   // then make a crude estimate.
+   DWORD data, data_size = sizeof(data);
++#if !defined(WINAPI_FAMILY) || WINAPI_FAMILY != WINAPI_FAMILY_TV_TITLE
+   if (IsWindowsXPOrGreater() &&
+       SUCCEEDED(
+           SHGetValueA(HKEY_LOCAL_MACHINE,
+                       "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
+                       "~MHz", nullptr, &data, &data_size)))
++#else
++  data = 1600; // Windows applications with WINAPI family of TV Title has a cpu frequency clock rate of 1.6Ghz according to documentation
++#endif
+     return static_cast<double>((int64_t)data *
+                                (int64_t)(1000 * 1000));  // was mhz
+ #elif defined (BENCHMARK_OS_SOLARIS)
+@@ -660,7 +672,7 @@
+ std::vector<double> GetLoadAvg() {
+ #if (defined BENCHMARK_OS_FREEBSD || defined(BENCHMARK_OS_LINUX) || \
+     defined BENCHMARK_OS_MACOSX || defined BENCHMARK_OS_NETBSD ||  \
+-    defined BENCHMARK_OS_OPENBSD) && !defined(__ANDROID__)
++    defined BENCHMARK_OS_OPENBSD) && !defined(__ANDROID__) && !defined(BENCHMARK_SYS_SYSCTL_H_UNSUPPORTED)
+   constexpr int kMaxSamples = 3;
+   std::vector<double> res(kMaxSamples, 0.0);
+   const int nelem = getloadavg(res.data(), kMaxSamples);
+diff -N -a -u -r benchmark-1.5.0.orig/src/timers.cc benchmark-1.5.0/src/timers.cc
+--- benchmark-1.5.0.orig/src/timers.cc	2019-05-13 14:42:18.000000000 -0500
++++ benchmark-1.5.0/src/timers.cc	2020-10-14 22:19:18.569818000 -0500
+@@ -22,13 +22,13 @@
+ #include <windows.h>
+ #else
+ #include <fcntl.h>
+-#ifndef BENCHMARK_OS_FUCHSIA
++#if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_SYS_RESOURCE_H_UNSUPPORTED)
+ #include <sys/resource.h>
+ #endif
+ #include <sys/time.h>
+ #include <sys/types.h>  // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
+ #include <unistd.h>
+-#if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX
++#if (defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX) && !defined(BENCHMARK_SYS_SYSCTL_H_UNSUPPORTED)
+ #include <sys/sysctl.h>
+ #endif
+ #if defined(BENCHMARK_OS_MACOSX)
+@@ -77,7 +77,7 @@
+           static_cast<double>(user.QuadPart)) *
+          1e-7;
+ }
+-#elif !defined(BENCHMARK_OS_FUCHSIA)
++#elif !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_TIME_S_SUPPORTED)
+ double MakeTime(struct rusage const& ru) {
+   return (static_cast<double>(ru.ru_utime.tv_sec) +
+           static_cast<double>(ru.ru_utime.tv_usec) * 1e-6 +
+@@ -130,6 +130,11 @@
+   if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &spec) == 0)
+     return MakeTime(spec);
+   DiagnoseAndExit("clock_gettime(CLOCK_PROCESS_CPUTIME_ID, ...) failed");
++#elif defined(CLOCK_THREAD_CPUTIME_ID)
++  struct timespec spec;
++  if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &spec) == 0)
++    return MakeTime(spec);
++  DiagnoseAndExit("clock_gettime(CLOCK_THREAD_CPUTIME_ID, ...) failed");
+ #else
+   struct rusage ru;
+   if (getrusage(RUSAGE_SELF, &ru) == 0) return MakeTime(ru);
+@@ -193,7 +198,11 @@
+         std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
+ #else
+     std::tm timeinfo;
++#if defined(BENCHMARK_TIME_S_SUPPORTED)
++    ::localtime_s(&now, &timeinfo);
++#else
+     ::localtime_r(&now, &timeinfo);
++#endif
+     written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+ #endif
+   } else {
+@@ -201,7 +210,11 @@
+     written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
+ #else
+     std::tm timeinfo;
++#if defined(BENCHMARK_TIME_S_SUPPORTED)
++    ::gmtime_s(&now, &timeinfo);
++#else
+     ::gmtime_r(&now, &timeinfo);
++#endif
+     written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+ #endif
+   }

+ 208 - 0
package-system/googlebenchmark/build_config.json

@@ -0,0 +1,208 @@
+{
+   "git_url":"https://github.com/google/benchmark.git",
+   "git_tag":"v1.5.0",
+   "package_name":"googlebenchmark",
+   "package_version":"1.5.0-rev2",
+   "package_url":"https://github.com/google/benchmark",
+   "package_license":"Apache-2.0",
+   "package_license_file":"LICENSE",
+   "cmake_find_template":"FindGoogleBenchmark.cmake.template",
+   "cmake_find_target":"FindGoogleBenchmark.cmake",
+   "Platforms":{
+      "Windows":{
+         "Windows":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "\"Visual Studio 15 2017\"",
+               "-A",
+               "x64",
+               "-T",
+               "host=x64",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "\"Visual Studio 15 2017\"",
+               "-A",
+               "x64",
+               "-T",
+               "host=x64",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               "Shlwapi"
+            ]
+         },
+         "Android":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "Ninja",
+               "-DCMAKE_TOOLCHAIN_FILE=%LY_ANDROID_NDK_ROOT%\\build\\cmake\\android.toolchain.cmake",
+               "-DANDROID_ABI=arm64-v8a",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Ninja",
+               "-DCMAKE_TOOLCHAIN_FILE=%LY_ANDROID_NDK_ROOT%\\build\\cmake\\android.toolchain.cmake",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         }
+      },
+      "Darwin":{
+         "Mac":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j",
+               "8"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         },
+         "iOS":{
+            "custom_cmake_install":true,
+            "cmake_generate_args_debug":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_SYSTEM_NAME=iOS",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0",
+               "-DCMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH=NO",
+               "-DCMAKE_IOS_INSTALL_COMBINED=NO",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_THREAD_LIBS_INIT=-pthread",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\""
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_SYSTEM_NAME=iOS",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0",
+               "-DCMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH=NO",
+               "-DCMAKE_IOS_INSTALL_COMBINED=NO",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_THREAD_LIBS_INIT=-pthread",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\""
+            ],
+            "cmake_build_args_debug":[
+               "--config",
+               "Debug",
+               "-j",
+               "8"
+            ],
+            "cmake_build_args_release":[
+               "--config",
+               "Release",
+               "-j",
+               "8"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         }
+      },
+      "Linux":{
+         "Linux":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Debug\"",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+               "-DHAVE_STD_REGEX=TRUE",
+               "-DBENCHMARK_ENABLE_TESTING=OFF",
+               "-DCMAKE_INSTALL_LIBDIR=\"lib/Release\"",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ],
+            "cmake_compile_definitions":[
+               
+            ],
+            "cmake_link_options":[
+               
+            ]
+         }
+      }
+   }
+}

+ 100 - 0
package-system/googletest/Findgoogletest.cmake.template

@@ -0,0 +1,100 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+# this file actually ingests the library and defines targets.
+
+# Googletest
+set(GOOGLETEST_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/googletest/include)
+set(GOOGLETEST_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/googletest/lib)
+
+set(GOOGLETEST_COMPILE_DEFINITIONS
+${CUSTOM_ADDITIONAL_COMPILE_DEFINITIONS})
+
+set(GOOGLETEST_LINK_OPTIONS
+${CUSTOM_ADDITIONAL_LINK_OPTIONS})
+
+# GTest
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GTest")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GTEST_LIBS_DEBUG   $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtestd$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GTEST_LIBS_RELEASE $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtest$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GTEST_LIBRARY
+        "$$<$$<CONFIG:profile>:$${GOOGLETEST_GTEST_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Release>:$${GOOGLETEST_GTEST_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Debug>:$${GOOGLETEST_GTEST_LIBS_DEBUG}>")
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GTEST_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GTEST_FOUND True)
+endif()
+
+# GTestMain
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GTestMain")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GTESTMAIN_LIBS_DEBUG   $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtest_maind$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GTESTMAIN_LIBS_RELEASE $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GTESTMAIN_LIBRARY
+        "$$<$$<CONFIG:profile>:$${GOOGLETEST_GTESTMAIN_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Release>:$${GOOGLETEST_GTESTMAIN_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Debug>:$${GOOGLETEST_GTESTMAIN_LIBS_DEBUG}>")
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GTESTMAIN_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GTESTMAIN_FOUND True)
+endif()
+
+# GMock
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GMock")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GMOCK_LIBS_DEBUG   $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmockd$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GMOCK_LIBS_RELEASE $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmock$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GMOCK_LIBRARY
+        "$$<$$<CONFIG:profile>:$${GOOGLETEST_GMOCK_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Release>:$${GOOGLETEST_GMOCK_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Debug>:$${GOOGLETEST_GMOCK_LIBS_DEBUG}>")
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GMOCK_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GMOCK_FOUND True)
+endif()
+
+
+# GMockMain
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GMockMain")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GMOCKMAIN_LIBS_DEBUG   $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmock_maind$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GMOCKMAIN_LIBS_RELEASE $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmock_main$${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(GOOGLETEST_GMOCKMAIN_LIBRARY
+        "$$<$$<CONFIG:profile>:$${GOOGLETEST_GMOCKMAIN_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Release>:$${GOOGLETEST_GMOCKMAIN_LIBS_RELEASE}>"
+        "$$<$$<CONFIG:Debug>:$${GOOGLETEST_GMOCKMAIN_LIBS_DEBUG}>")
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GMOCKMAIN_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GMOCKMAIN_FOUND True)
+endif()

+ 80 - 0
package-system/googletest/FindgoogletestRelOnly.cmake.template

@@ -0,0 +1,80 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+# this file actually ingests the library and defines targets.
+
+# Googletest
+set(GOOGLETEST_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/googletest/include)
+set(GOOGLETEST_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/googletest/lib)
+
+set(GOOGLETEST_COMPILE_DEFINITIONS
+${CUSTOM_ADDITIONAL_COMPILE_DEFINITIONS})
+
+set(GOOGLETEST_LINK_OPTIONS
+${CUSTOM_ADDITIONAL_LINK_OPTIONS})
+
+# GTest
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GTest")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GTEST_LIBRARY $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtest$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GTEST_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GTEST_FOUND True)
+endif()
+
+# GTestMain
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GTestMain")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GTESTMAIN_LIBRARY $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GTESTMAIN_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GTESTMAIN_FOUND True)
+endif()
+
+# GMock
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GMock")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GMOCK_LIBRARY $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmock$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GMOCK_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GMOCK_FOUND True)
+endif()
+
+
+# GMockMain
+#################################################################
+set(TARGET_WITH_NAMESPACE "3rdParty::googletest::GMockMain")
+if (NOT TARGET $${TARGET_WITH_NAMESPACE})
+
+    set(GOOGLETEST_GMOCKMAIN_LIBRARY $${GOOGLETEST_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}gmock_main$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+    add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+    ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_INCLUDE_DIR})
+    target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_GMOCKMAIN_LIBRARY})
+    target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_LINK_OPTIONS})
+    target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${GOOGLETEST_COMPILE_DEFINITIONS})
+    set(GOOGLETEST_GMOCKMAIN_FOUND True)
+endif()

+ 154 - 0
package-system/googletest/build_config.json

@@ -0,0 +1,154 @@
+{
+   "git_url":"https://github.com/google/googletest.git",
+   "git_tag":"release-1.8.1",
+   "package_name":"googletest",
+   "package_version":"1.8.1-rev4",
+   "package_url":"https://github.com/google/googletest",
+   "package_license":"BSD-3-Clause",
+   "package_license_file":"LICENSE",
+   "cmake_find_template":"Findgoogletest.cmake.template",
+   "cmake_find_target":"Findgoogletest.cmake",
+   "Platforms":{
+      "Windows":{
+         "Windows":{
+            "cmake_generate_args":[
+               "-G",
+               "\"Visual Studio 15 Win64\"",
+               "-DCMAKE_CXX_FLAGS=/Zc:__cplusplus",
+               "-Dgtest_force_shared_crt=ON"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               "$<$<STREQUAL:${PAL_TRAIT_COMPILER_ID},Clang>:-Wl,>/ignore:4099"
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         },
+         "Android":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "Ninja",
+               "-DCMAKE_TOOLCHAIN_FILE=%LY_ANDROID_NDK_ROOT%\\build\\cmake\\android.toolchain.cmake",
+               "-DANDROID_ABI=arm64-v8a",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC\"",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Ninja",
+               "-DCMAKE_TOOLCHAIN_FILE=%LY_ANDROID_NDK_ROOT%\\build\\cmake\\android.toolchain.cmake",
+               "-DANDROID_ABI=arm64-v8a",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC\"",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "custom_additional_compile_definitions":[
+               "GTEST_HAS_TR1_TUPLE=0",
+               "GTEST_OS_SUPPORTS_DEATH_TEST=0"
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         }
+      },
+      "Darwin":{
+         "Mac":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_find_template":"FindgoogletestRelOnly.cmake.template",
+            "cmake_generate_args":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.12",
+               "-DCMAKE_OSX_ARCHITECTURES=x86_64",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC -fno-aligned-allocation\"",
+               "-DCMAKE_CXX_STANDARD=17"
+            ],
+            "cmake_build_args":[
+               "-j",
+               "8"
+            ],
+            "custom_additional_compile_definitions":[
+               
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         },
+         "iOS":{
+            "custom_cmake_install":true,
+            "cmake_generate_args":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_SYSTEM_NAME=iOS",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_OSX_ARCHITECTURES=arm64",
+               "-DCMAKE_THREAD_LIBS_INIT=-pthread",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC -fno-aligned-allocation\""
+            ],
+            "cmake_build_args":[
+               
+            ],
+            "custom_additional_compile_definitions":[
+               "GTEST_HAS_TR1_TUPLE=0",
+               "GTEST_OS_SUPPORTS_DEATH_TEST=0"
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         }
+      },
+      "Linux":{
+         "Linux":{
+            "cmake_generate_args_debug":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_C_COMPILER=clang-6.0",
+               "-DCMAKE_CXX_COMPILER=clang++-6.0",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC -fno-aligned-allocation\"",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_C_COMPILER=clang-6.0",
+               "-DCMAKE_CXX_COMPILER=clang++-6.0",
+               "-DCMAKE_CXX_FLAGS=\"-fPIC -fno-aligned-allocation\"",
+               "-DCMAKE_CXX_STANDARD=17",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "-j"
+            ],
+            "custom_additional_compile_definitions":[
+               "GTEST_HAS_TR1_TUPLE=0",
+               "GTEST_OS_SUPPORTS_DEATH_TEST=0"
+            ],
+            "custom_additional_link_options":[
+               
+            ],
+            "custom_additional_libraries":[
+               
+            ]
+         }
+      }
+   }
+}

+ 108 - 0
package-system/googletest/googletest-release-1.8.1.patch

@@ -0,0 +1,108 @@
+diff -ru googletest-release-1.8.1-orig/googletest/include/gtest/internal/custom/gtest-port.h googletest-release-1.8.1/googletest/include/gtest/internal/custom/gtest-port.h
+--- googletest-release-1.8.1-orig/googletest/include/gtest/internal/custom/gtest-port.h	2018-08-31 10:21:58.000000000 -0500
++++ googletest-release-1.8.1/googletest/include/gtest/internal/custom/gtest-port.h	2019-08-28 18:10:03.329550600 -0500
+@@ -34,4 +34,32 @@
+ #ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+ #define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+ 
++#if !defined(GTEST_HAS_LOCALTIME_S)
++#define GTEST_HAS_LOCALTIME_S 0
++#endif
++
++#if !defined(GTEST_HAS_IS_ATTY)
++#define GTEST_HAS_IS_ATTY 1
++#endif
++
++#if !defined(GTEST_HAS_CHDIR)
++#define GTEST_HAS_CHDIR 1
++#endif
++
++#if !defined(GTEST_HAS_GETENV)
++#define GTEST_HAS_GETENV 1
++#endif
++
++#if !defined(GTEST_OS_SUPPORTS_DEATH_TEST)
++#define GTEST_OS_SUPPORTS_DEATH_TEST 1
++#endif
++
++#if !defined(GTEST_HAS_GETCWD)
++#define GTEST_HAS_GETCWD 1
++#endif
++
++#if !defined(GTEST_STUB_GETCWD_PATH)
++#define GTEST_STUB_GETCWD_PATH ""
++#endif
++
+ #endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+diff -ru googletest-release-1.8.1-orig/googletest/include/gtest/internal/gtest-port.h googletest-release-1.8.1/googletest/include/gtest/internal/gtest-port.h
+--- googletest-release-1.8.1-orig/googletest/include/gtest/internal/gtest-port.h	2018-08-31 10:21:58.000000000 -0500
++++ googletest-release-1.8.1/googletest/include/gtest/internal/gtest-port.h	2019-08-30 06:27:22.575984300 -0500
+@@ -829,7 +829,7 @@
+      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) ||          \
+      GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
+      GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || \
+-     GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)
++     GTEST_OS_NETBSD || GTEST_OS_FUCHSIA) && (GTEST_OS_SUPPORTS_DEATH_TEST)
+ # define GTEST_HAS_DEATH_TEST 1
+ #endif
+ 
+@@ -2485,7 +2485,11 @@
+ typedef struct stat StatStruct;
+ 
+ inline int FileNo(FILE* file) { return fileno(file); }
++#if !GTEST_HAS_IS_ATTY
++inline int IsATTY(int fd) { return 0; }
++#else
+ inline int IsATTY(int fd) { return isatty(fd); }
++#endif
+ inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+ inline int StrCaseCmp(const char* s1, const char* s2) {
+   return strcasecmp(s1, s2);
+@@ -2508,7 +2512,7 @@
+ // StrError() aren't needed on Windows CE at this time and thus not
+ // defined there.
+ 
+-#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
++#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && GTEST_HAS_CHDIR
+ inline int ChDir(const char* dir) { return chdir(dir); }
+ #endif
+ inline FILE* FOpen(const char* path, const char* mode) {
+@@ -2532,7 +2536,7 @@
+ inline const char* StrError(int errnum) { return strerror(errnum); }
+ #endif
+ inline const char* GetEnv(const char* name) {
+-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
++#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || !GTEST_HAS_GETENV
+   // We are on Windows CE, which has no environment variables.
+   static_cast<void>(name);  // To prevent 'unused argument' warning.
+   return NULL;
+diff -ru googletest-release-1.8.1-orig/googletest/src/gtest.cc googletest-release-1.8.1/googletest/src/gtest.cc
+--- googletest-release-1.8.1-orig/googletest/src/gtest.cc	2018-08-31 10:21:58.000000000 -0500
++++ googletest-release-1.8.1/googletest/src/gtest.cc	2019-08-28 17:12:06.397466300 -0500
+@@ -3628,6 +3628,8 @@
+     return false;
+   *out = *tm_ptr;
+   return true;
++#elif GTEST_HAS_LOCALTIME_S
++  return localtime_s(&seconds, out) != nullptr;
+ #else
+   return localtime_r(&seconds, out) != NULL;
+ #endif
+diff -ru googletest-release-1.8.1-orig/googletest/src/gtest-filepath.cc googletest-release-1.8.1/googletest/src/gtest-filepath.cc
+--- googletest-release-1.8.1-orig/googletest/src/gtest-filepath.cc	2018-08-31 10:21:58.000000000 -0500
++++ googletest-release-1.8.1/googletest/src/gtest-filepath.cc	2021-01-04 14:53:54.173667600 -0600
+@@ -104,7 +104,14 @@
+   return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
+ #else
+   char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
++#if GTEST_HAS_GETCWD
+   char* result = getcwd(cwd, sizeof(cwd));
++#else
++  #define GTEST_STRINGIFY_WRAP(name) GTEST_STRINGIFY_(name)
++  const char* result = GTEST_STRINGIFY_WRAP(GTEST_STUB_GETCWD_PATH);
++  #undef GTEST_STRINGIFY_WRAP
++  strncpy(cwd, result, sizeof(cwd) - 1);
++#endif
+ # if GTEST_OS_NACL
+   // getcwd will likely fail in NaCl due to the sandbox, so return something
+   // reasonable. The user may have provided a shim implementation for getcwd,

+ 29 - 0
package-system/libsamplerate/Findlibsamplerate.cmake.template

@@ -0,0 +1,29 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+# libsamplerate
+set(TARGET_WITH_NAMESPACE 3rdParty::libsamplerate)
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(LIBSAMPLERATE_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/libsamplerate/include)
+set(LIBSAMPLERATE_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/libsamplerate/lib)
+
+set(LIBSAMPLERATE_COMPILE_DEFINITIONS ${CUSTOM_ADDITIONAL_COMPILE_DEFINITIONS})
+set(LIBSAMPLERATE_LINK_OPTIONS ${CUSTOM_ADDITIONAL_LINK_OPTIONS})
+
+set(LIBSAMPLERATE_LIBRARY $${LIBSAMPLERATE_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}samplerate$${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${LIBSAMPLERATE_INCLUDE_DIR})
+target_link_libraries($${TARGET_WITH_NAMESPACE} INTERFACE $${LIBSAMPLERATE_LIBRARY})
+target_link_options($${TARGET_WITH_NAMESPACE} INTERFACE $${LIBSAMPLERATE_LINK_OPTIONS})
+target_compile_definitions($${TARGET_WITH_NAMESPACE} INTERFACE $${LIBSAMPLERATE_COMPILE_DEFINITIONS})
+
+set(LIBSAMPLERATE_FOUND True)

+ 139 - 0
package-system/libsamplerate/build_config.json

@@ -0,0 +1,139 @@
+{
+   "git_url":"https://github.com/libsndfile/libsamplerate.git",
+   "git_tag":"0.2.1",
+   "package_name":"libsamplerate",
+   "package_version":"0.2.1-rev2",
+   "package_url":"http://libsndfile.github.io/libsamplerate/",
+   "package_license":"BSD-2-Clause",
+   "package_license_file":"COPYING",
+   "cmake_find_template":"Findlibsamplerate.cmake.template",
+   "cmake_find_target":"Findlibsamplerate.cmake",
+   "Platforms":{
+      "Windows":{
+         "Windows":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_generate_args":[
+               "-G",
+               "\"Visual Studio 16 2019\""
+            ],
+            "cmake_build_args":[
+               "--target samplerate"
+            ],
+            "custom_additional_compile_definitions":[
+            ],
+            "custom_additional_link_options":[
+            ],
+            "custom_additional_libraries":[
+            ]
+         },
+         "Android":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_generate_args_debug":[
+               "-G",
+               "Ninja",
+               "-DANDROID_ABI=arm64-v8a",
+               "-DANDROID_PLATFORM=android-29",
+               "-DLY_NDK_DIR=%LY_ANDROID_NDK_ROOT%",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Ninja",
+               "-DANDROID_ABI=arm64-v8a",
+               "-DANDROID_PLATFORM=android-29",
+               "-DLY_NDK_DIR=%LY_ANDROID_NDK_ROOT%",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "--target samplerate"
+            ],
+            "custom_additional_compile_definitions":[
+            ],
+            "custom_additional_link_options":[
+            ],
+            "custom_additional_libraries":[
+            ]
+         }
+      },
+      "Darwin":{
+         "Mac":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_generate_args":[
+               "-G",
+               "Xcode"
+            ],
+            "cmake_build_args":[
+               "--target samplerate"
+            ],
+            "custom_additional_compile_definitions":[
+            ],
+            "custom_additional_link_options":[
+            ],
+            "custom_additional_libraries":[
+            ]
+         },
+         "iOS":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_generate_args":[
+               "-G",
+               "Xcode",
+               "-DCMAKE_SYSTEM_NAME=iOS",
+               "-DCMAKE_OSX_ARCHITECTURES=arm64"
+            ],
+            "cmake_generate_args_debug":[
+               "-DCMAKE_INSTALL_CONFIG_NAME=Debug-iphoneos"
+            ],
+            "cmake_generate_args_release":[
+               "-DCMAKE_INSTALL_CONFIG_NAME=Release-iphoneos"
+            ],
+            "cmake_build_args":[
+               "--target samplerate"
+            ],
+            "custom_additional_compile_definitions":[
+            ],
+            "custom_additional_link_options":[
+            ],
+            "custom_additional_libraries":[
+            ]
+         }
+      },
+      "Linux":{
+         "Linux":{
+            "build_configs":[
+               "Release"
+            ],
+            "cmake_generate_args_debug":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_C_COMPILER=clang-6.0",
+               "-DCMAKE_CXX_COMPILER=clang++-6.0",
+               "-DCMAKE_BUILD_TYPE=Debug"
+            ],
+            "cmake_generate_args_release":[
+               "-G",
+               "Unix\\ Makefiles",
+               "-DCMAKE_C_COMPILER=clang-6.0",
+               "-DCMAKE_CXX_COMPILER=clang++-6.0",
+               "-DCMAKE_BUILD_TYPE=Release"
+            ],
+            "cmake_build_args":[
+               "--target samplerate"
+            ],
+            "custom_additional_compile_definitions":[
+            ],
+            "custom_additional_link_options":[
+            ],
+            "custom_additional_libraries":[
+            ]
+         }
+      }
+   }
+}

+ 28 - 0
package-system/mcpp/Findmcpp.cmake.template

@@ -0,0 +1,28 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(MY_NAME "mcpp")
+set(TARGET_WITH_NAMESPACE "3rdParty::$${MY_NAME}")
+if (TARGET $${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set($${MY_NAME}_INCLUDE_DIR $${CMAKE_CURRENT_LIST_DIR}/mcpp/include)
+set($${MY_NAME}_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/mcpp/lib)
+set($${MY_NAME}_BINARY_DIR $${CMAKE_CURRENT_LIST_DIR}/mcpp/lib) #"lib" here is not a typo
+
+set($${MY_NAME}_LIBRARY $${$${MY_NAME}_LIBS_DIR}/${MCPP_STATIC_LIB})
+set($${MY_NAME}_RUNTIME_DEPENDENCIES $${$${MY_NAME}_BINARY_DIR}/${MCPP_SHARED_LIB})
+
+add_library($${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(TARGET $${TARGET_WITH_NAMESPACE} INTERFACE $${$${MY_NAME}_INCLUDE_DIR})
+target_link_libraries($${TARGET_WITH_NAMESPACE} 
+                INTERFACE $${$${MY_NAME}_LIBRARY})
+ly_add_target_files(TARGETS $${TARGET_WITH_NAMESPACE} FILES $${$${MY_NAME}_RUNTIME_DEPENDENCIES})
+
+set($${MY_NAME}_FOUND True)

+ 398 - 0
package-system/mcpp/get_and_build_mcpp.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+import argparse
+import logging
+import os
+import pathlib
+import platform
+import requests
+import shutil
+import string
+import subprocess
+import tarfile
+import time
+
+
+SCRIPT_PATH = pathlib.Path(__file__).parent
+PATCH_FILE = SCRIPT_PATH / "mcpp-2.7.2-az.2.patch"
+SOURCE_NAME = "mcpp-2.7.2"
+SOURCE_TAR_FILE = f"{SOURCE_NAME}.tar.gz"
+SOURCEFORGE_URL = "https://sourceforge.net/projects/mcpp/files/mcpp/V.2.7.2"
+SOURCEFORGE_DOWNLOAD_URL = f"{SOURCEFORGE_URL}/{SOURCE_TAR_FILE}/download"
+
+PLATFORM_LINUX = 'linux'
+PLATFORM_MAC = 'mac'
+PLATFORM_WINDOWS = 'windows'
+
+if platform.system() == 'Linux':
+    platform_name = PLATFORM_LINUX
+    shared_lib_name = 'libmcpp.so'
+    static_lib_name = 'libmcpp.a'
+elif platform.system() == 'Darwin':
+    platform_name = PLATFORM_MAC
+    shared_lib_name = 'libmcpp.dylib'
+    static_lib_name = 'libmcpp.a'
+elif platform.system() == 'Windows':
+    platform_name = PLATFORM_WINDOWS
+    static_lib_name = 'mcpp0.lib'
+    shared_lib_name = 'mcpp0.dll'
+
+    # Note: If we are running from windows, this script must be run from a visual studio command prompt
+    # We will check the system environment to make sure that 'INCLUDE', 'LIB', 'LIBPATH' are set
+    for vs_env_key in ('INCLUDE', 'LIB', 'LIBPATH'):
+        if os.environ.get(vs_env_key) is None:
+            print("This script must be run from a visual studio command prompt, or the visual studio command line"
+                  " environments must be set")
+            exit(1)
+else:
+    assert False, "Invalid platform"
+
+assert platform_name in (PLATFORM_LINUX, PLATFORM_MAC, PLATFORM_WINDOWS), f"Invalid platform_name {platform_name}"
+
+TARGET_3PP_PACKAGE_FOLDER = SCRIPT_PATH.parent / f'mcpp-{platform_name}'
+
+MCPP_DETAIL = f"""
+The MCPP package will be patched and built from the following sources
+
+Sourceforge URL                    : {SOURCEFORGE_URL}
+Source name                        : {SOURCE_NAME}
+Patch File                         : {PATCH_FILE}
+Target Pre-package Platform target : {TARGET_3PP_PACKAGE_FOLDER}
+Example command:
+
+python get_and_build_linux.sh mcpp-2.7.2_az.1-rev1-{platform_name}
+"""
+
+
+def execute_cmd(cmd, cwd=None, shell=False, suppress_std_err=False, env=None):
+    logging.debug(f"[DEBUG] Calling {subprocess.list2cmdline(cmd)}")
+    if shell:
+        cmd = subprocess.list2cmdline(cmd)
+    return subprocess.call(cmd,
+                           shell=shell,
+                           cwd=cwd,
+                           env=env,
+                           stderr=subprocess.DEVNULL if suppress_std_err else subprocess.STDOUT)
+
+
+def prepare_temp_folder(temp_folder):
+    if temp_folder.exists():
+        shutil.rmtree(str(temp_folder.resolve()), ignore_errors=True)
+    os.makedirs(temp_folder, exist_ok=True)
+    return True
+
+
+def download_from_source_forge(source_forge_download_url, temp_folder):
+
+    try:
+        request = requests.get(source_forge_download_url, allow_redirects=True)
+        target_file = temp_folder / SOURCE_TAR_FILE
+        if target_file.is_file():
+            target_file.unlink()
+
+        with open(str(target_file.resolve()), 'wb') as request_stream:
+            bytes_written = request_stream.write(request.content)
+
+        logging.debug(f'[DEBUG] {SOURCE_TAR_FILE} downloaded ({bytes_written} bytes)')
+        return True
+    except Exception as e:
+        logging.fatal(f'[FATAL] Error downloading from {source_forge_download_url} : {e}')
+        return False
+
+
+def extract_tarfile(temp_folder):
+    try:
+        target_file = temp_folder / SOURCE_TAR_FILE
+        if not target_file.is_file():
+            logging.error(f'[ERROR] Missing expected tar file {target_file}')
+        tar = tarfile.open(str(target_file), 'r:gz')
+        tar.extractall(path=str(temp_folder.resolve()))
+        logging.debug(f'[DEBUG] {SOURCE_TAR_FILE} extracted to ({str(temp_folder.resolve())})')
+        return True
+    except Exception as e:
+        logging.fatal(f'[FATAL] extracting tar file {target_file} : {e}')
+        return False
+
+
+def apply_patch(temp_folder, patch_file):
+
+    pristine_source_path = str((temp_folder / SOURCE_NAME).resolve())
+
+    # Git apply for some reason fails on windows, but works on other platforms. We will first try 'git', and if that
+    # fails, we will try 'patch'
+    apply_patch_cmds = [
+        ('git', ['apply', str(patch_file.resolve())]),
+        ('patch', ['--strip=1', f'--input={str(patch_file.resolve())}'])
+    ]
+
+    try:
+        patched = False
+        for apply_patch_cmd in apply_patch_cmds:
+            patch_cmd = apply_patch_cmd[0]
+            logging.info(f"Attempt to patch with {patch_cmd}")
+
+            result = execute_cmd([patch_cmd, '--version'], shell=True, suppress_std_err=True)
+            if result != 0:
+                logging.debug(f"[DEBUG] Unable to locate cmd {patch_cmd} for patching.")
+                continue
+
+            patch_full_cmd = [patch_cmd]
+            patch_full_cmd.extend(apply_patch_cmd[1])
+            result = execute_cmd(patch_full_cmd, shell=True, cwd=pristine_source_path)
+            if result != 0:
+                logging.debug(f"[DEBUG] cmd {patch_cmd} failed for patching.")
+                continue
+            patched = True
+            break
+
+        if not patched:
+            logging.error(f"[ERROR] Unable to patch. Make sure to 'patch' or 'git' is installed.")
+
+        return patched
+    except Exception as e:
+        logging.fatal(f'[FATAL] Error applying patch file {patch_file} : {e}')
+        return False
+
+
+def configure_build(temp_folder):
+    try:
+        pristine_source_path = str((temp_folder / SOURCE_NAME).resolve())
+
+        if platform_name == PLATFORM_WINDOWS:
+            # Windows does not have a configure, instead it will use a modified visualc.mak directly
+            # Copy the modified visualc.mak file to the patched source directory for the subsequent build step
+            src_visualc_mak = SCRIPT_PATH / 'visualc.mak'
+            dst_visualc_mak = temp_folder / SOURCE_NAME / 'src' / 'visualc.mak'
+            shutil.copyfile(str(src_visualc_mak.resolve()), str(dst_visualc_mak.resolve()))
+        else:
+            if platform_name == PLATFORM_MAC:
+                # For mac, we need to disable the 'implicit-function-declaration' or else the build will fail
+                env_copy = os.environ.copy()
+                env_copy['CFLAGS'] = '-Wno-implicit-function-declaration'
+            else:
+                env_copy = None
+
+            # Mac and Linux use the built in ./configure command
+            if execute_cmd(['./configure',
+                            '--with-pic',
+                            '--enable-mcpplib'],
+                           cwd=pristine_source_path,
+                           suppress_std_err=True,
+                           env=env_copy) != 0:
+                logging.fatal(f'[ERROR] Error configuring build.')
+                return False
+
+        return True
+    except Exception as e:
+        logging.fatal(f'[FATAL] Error configuring build : {e}')
+        return False
+
+
+def build_from_source(temp_folder):
+    try:
+
+        if platform_name == PLATFORM_WINDOWS:
+            # Windows will use a precreated visualc.mak file instead of configure/make.
+            source_working_path = str((temp_folder / SOURCE_NAME / 'src').resolve())
+
+            build_cmds = [
+                ['nmake', '/f', 'visualc.mak', 'COMPILER=MSC'],
+                ['nmake', '/f', 'visualc.mak', 'COMPILER=MSC', 'MCPP_LIB=1', 'mcpplib']
+            ]
+
+            for build_cmd in build_cmds:
+                if execute_cmd(build_cmd, cwd=source_working_path) != 0:
+                    logging.fatal(f'[ERROR] Error building from source.')
+                    return False
+
+        else:
+            # Mac/Linux will use 'make' to build
+            pristine_source_path = str((temp_folder / SOURCE_NAME).resolve())
+            result = execute_cmd(['make'],
+                                 cwd=pristine_source_path,
+                                 suppress_std_err=True)
+            if result != 0:
+                logging.fatal(f'[ERROR] Error building from source.')
+                return False
+
+        return True
+    except Exception as e:
+        logging.fatal(f'[FATAL] Error building from source : {e}')
+        return False
+
+
+def copy_build_artifacts(temp_folder):
+    # Copying LICENSE, headers and libs
+    source_path = temp_folder / SOURCE_NAME
+    target_mcpp_root = TARGET_3PP_PACKAGE_FOLDER / 'mcpp'
+
+    file_copy_tuples = [
+        (source_path / 'LICENSE', target_mcpp_root),
+        (source_path / 'src' / 'mcpp_lib.h', target_mcpp_root / 'include'),
+        (source_path / 'src' / 'mcpp_out.h', target_mcpp_root / 'include')
+        ]
+    if platform_name == 'linux':
+        file_copy_tuples.extend([
+            (source_path / 'src' / '.libs' / 'libmcpp.a', target_mcpp_root / 'lib'),
+            (source_path / 'src' / '.libs' / 'libmcpp.so.0.3.0', target_mcpp_root / 'lib'),
+            (source_path / 'src' / '.libs' / 'mcpp', target_mcpp_root / 'lib')
+        ])
+    elif platform_name == 'mac':
+        file_copy_tuples.extend([
+            (source_path / 'src' / '.libs' / 'libmcpp.a', target_mcpp_root / 'lib'),
+            (source_path / 'src' / '.libs' / 'libmcpp.0.3.0.dylib', target_mcpp_root / 'lib'),
+            (source_path / 'src' / '.libs' / 'mcpp', target_mcpp_root / 'lib')
+        ])
+    elif platform_name == 'windows':
+        file_copy_tuples.extend([
+            (source_path / 'src' / 'mcpp0.dll', target_mcpp_root / 'lib'),
+            (source_path / 'src' / 'mcpp0.lib', target_mcpp_root / 'lib'),
+            (source_path / 'src' / 'mcpp.exe', target_mcpp_root / 'lib')
+        ])
+
+    for file_copy_tuple in file_copy_tuples:
+        src = file_copy_tuple[0]
+        dst = file_copy_tuple[1]
+        if not src.is_file():
+            logging.error(f'[ERROR] Missing source file {str(src)}')
+            return False
+        if not dst.is_dir():
+            os.makedirs(str(dst.resolve()))
+        shutil.copy2(str(src), str(dst))
+
+    dst_lib_folder = target_mcpp_root / 'lib'
+    if platform_name == 'linux':
+        base_shared_lib_name = 'libmcpp.so.0.3.0'
+        symlinks = ['libmcpp.so.0', 'libmcpp.so']
+    elif platform_name == 'mac':
+        base_shared_lib_name = 'libmcpp.0.3.0.dylib'
+        symlinks = ['libmcpp.0.dylib', 'libmcpp.dylib']
+    else:
+        base_shared_lib_name = None
+        symlinks = None
+
+    if base_shared_lib_name and symlinks:
+        for symlink in symlinks:
+            execute_cmd(['ln', '-s', base_shared_lib_name, symlink], cwd=str(dst_lib_folder))
+
+    return True
+
+
+def create_3PP_package(temp_folder, package_label):
+
+    if TARGET_3PP_PACKAGE_FOLDER.is_dir():
+        shutil.rmtree(str(TARGET_3PP_PACKAGE_FOLDER.resolve()), ignore_errors=True)
+    os.makedirs(str(TARGET_3PP_PACKAGE_FOLDER.resolve()), exist_ok=True)
+
+    # Generate the find cmake file from the template file
+    find_cmake_template_file = SCRIPT_PATH / f'Findmcpp.cmake.template'
+    assert find_cmake_template_file.is_file(), f"Missing template file {find_cmake_template_file}"
+    find_cmake_template_file_content = find_cmake_template_file.read_text("UTF-8", "ignore")
+
+    template_env = {
+        "MCPP_SHARED_LIB": shared_lib_name,
+        "MCPP_STATIC_LIB": static_lib_name
+    }
+
+    find_cmake_content = string.Template(find_cmake_template_file_content).substitute(template_env)
+    dst_find_cmake = TARGET_3PP_PACKAGE_FOLDER / 'Findmcpp.cmake'
+    dst_find_cmake.write_text(find_cmake_content)
+
+    # Generate the PackageInfo
+    package_info_content = f'''
+{{
+    "PackageName" : "{package_label}-{platform_name}",
+    "URL"         : "{SOURCEFORGE_URL}",
+    "License"     : "custom",
+    "LicenseFile" : "mcpp/LICENSE"
+}}
+'''
+    package_info_target = TARGET_3PP_PACKAGE_FOLDER / 'PackageInfo.json'
+    logging.debug(f'[DEBUG] Generating  {package_info_target}')
+    package_info_target.write_text(package_info_content)
+
+    return copy_build_artifacts(temp_folder)
+
+
+def main():
+
+    parser = argparse.ArgumentParser(description="Script to build the O3DE complaint 3rd Party Package version of the mcpp open source project.",
+                                     formatter_class=argparse.RawDescriptionHelpFormatter,
+                                     epilog=MCPP_DETAIL)
+    parser.add_argument(
+        'package_label',
+        help="The package name and revision"
+    )
+    parser.add_argument(
+        '--debug',
+        help="Enable debug messages",
+        action="store_true"
+    )
+    args = parser.parse_args()
+    logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG if args.debug else logging.INFO)
+
+    logging.info("Preparing temp working folder")
+    temp_folder = SCRIPT_PATH / 'temp'
+    if not prepare_temp_folder(temp_folder):
+        return False
+
+    logging.info("Downloading from sourceforge")
+    if not download_from_source_forge(SOURCEFORGE_DOWNLOAD_URL, temp_folder):
+        return False
+
+    logging.info("Extracting source tarball")
+    if not extract_tarfile(temp_folder):
+        return False
+
+    logging.info("Apply Patch File")
+    if not apply_patch(temp_folder, PATCH_FILE):
+        return False
+
+    logging.info("Configuring Build")
+    if not configure_build(temp_folder):
+        return False
+
+    logging.info("Building from source")
+    if not build_from_source(temp_folder):
+        return False
+
+    logging.info("Creating 3PP Target")
+    if not create_3PP_package(temp_folder, args.package_label):
+        return False
+
+    # If successful, delete the temp folder
+    if temp_folder.exists():
+        shutil.rmtree(str(temp_folder.resolve()), ignore_errors=True)
+
+    logging.info("MCPP Package complete")
+
+
+    return True
+
+
+if __name__ == '__main__':
+
+    start = time.time()
+
+    result = main()
+
+    elapsed = time.time() - start
+    hour = int(elapsed // 3600)
+    minute = int((elapsed - 3600*hour) // 60)
+    seconds = int((elapsed - 3600*hour - 60*minute))
+
+    logging.info(f'Total time {hour}:{minute:02d}:{seconds:02d}')
+
+    if result:
+        exit(0)
+    else:
+        exit(1)
+

+ 844 - 0
package-system/mcpp/mcpp-2.7.2-az.2.patch

@@ -0,0 +1,844 @@
+diff --git a/config/config.guess b/config/config.guess
+index 396482d..e3ef63f 100755
+--- a/config/config.guess
++++ b/config/config.guess
+@@ -1,10 +1,9 @@
+ #! /bin/sh
+ # Attempt to guess a canonical system name.
+ #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+-#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+-#   Inc.
++#   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 
+-timestamp='2006-07-02'
++timestamp='2005-12-13'
+ 
+ # This file is free software; you can redistribute it and/or modify it
+ # under the terms of the GNU General Public License as published by
+@@ -107,7 +106,7 @@ set_cc_for_build='
+ trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+ trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+ : ${TMPDIR=/tmp} ;
+- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
++ { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+  { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+  { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+  { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+@@ -207,11 +206,8 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+     *:ekkoBSD:*:*)
+ 	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+ 	exit ;;
+-    *:SolidBSD:*:*)
+-	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+-	exit ;;
+     macppc:MirBSD:*:*)
+-	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
++	echo powerppc-unknown-mirbsd${UNAME_RELEASE}
+ 	exit ;;
+     *:MirBSD:*:*)
+ 	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+@@ -768,14 +764,7 @@ EOF
+ 	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+ 	exit ;;
+     *:FreeBSD:*:*)
+-	case ${UNAME_MACHINE} in
+-	    pc98)
+-		echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+-	    amd64)
+-		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+-	    *)
+-		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+-	esac
++	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+ 	exit ;;
+     i*:CYGWIN*:*)
+ 	echo ${UNAME_MACHINE}-pc-cygwin
+@@ -790,11 +779,8 @@ EOF
+     i*:PW*:*)
+ 	echo ${UNAME_MACHINE}-pc-pw32
+ 	exit ;;
+-    x86:Interix*:[3456]*)
+-	echo i586-pc-interix${UNAME_RELEASE}
+-	exit ;;
+-    EM64T:Interix*:[3456]*)
+-	echo x86_64-unknown-interix${UNAME_RELEASE}
++    x86:Interix*:[345]*)
++	echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//'
+ 	exit ;;
+     [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+ 	echo i${UNAME_MACHINE}-pc-mks
+@@ -831,9 +817,6 @@ EOF
+     arm*:Linux:*:*)
+ 	echo ${UNAME_MACHINE}-unknown-linux-gnu
+ 	exit ;;
+-    avr32*:Linux:*:*)
+-	echo ${UNAME_MACHINE}-unknown-linux-gnu
+-	exit ;;
+     cris:Linux:*:*)
+ 	echo cris-axis-linux-gnu
+ 	exit ;;
+@@ -868,11 +851,7 @@ EOF
+ 	#endif
+ 	#endif
+ EOF
+-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+-	    /^CPU/{
+-		s: ::g
+-		p
+-	    }'`"
++	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '/^CPU/{s: ::g;p;}'`"
+ 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+ 	;;
+     mips64:Linux:*:*)
+@@ -891,11 +870,7 @@ EOF
+ 	#endif
+ 	#endif
+ EOF
+-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+-	    /^CPU/{
+-		s: ::g
+-		p
+-	    }'`"
++	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '/^CPU/{s: ::g;p;}'`"
+ 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+ 	;;
+     or32:Linux:*:*)
+@@ -992,7 +967,7 @@ EOF
+ 	LIBC=gnulibc1
+ 	# endif
+ 	#else
+-	#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
++	#if defined(__INTEL_COMPILER) || defined(__PGI)
+ 	LIBC=gnu
+ 	#else
+ 	LIBC=gnuaout
+@@ -1002,11 +977,7 @@ EOF
+ 	LIBC=dietlibc
+ 	#endif
+ EOF
+-	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+-	    /^LIBC/{
+-		s: ::g
+-		p
+-	    }'`"
++	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '/^LIBC/{s: ::g;p;}'`"
+ 	test x"${LIBC}" != x && {
+ 		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+ 		exit
+diff --git a/config/config.sub b/config/config.sub
+index 387c18d..2851647 100755
+--- a/config/config.sub
++++ b/config/config.sub
+@@ -1,10 +1,9 @@
+ #! /bin/sh
+ # Configuration validation subroutine script.
+ #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+-#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+-#   Inc.
++#   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 
+-timestamp='2006-07-02'
++timestamp='2005-12-11'
+ 
+ # This file is (in principle) common to ALL GNU software.
+ # The presence of a machine in this file suggests that SOME GNU software
+@@ -241,7 +240,7 @@ case $basic_machine in
+ 	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+ 	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+ 	| am33_2.0 \
+-	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
++	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+ 	| bfin \
+ 	| c4x | clipper \
+ 	| d10v | d30v | dlx | dsp16xx \
+@@ -249,8 +248,7 @@ case $basic_machine in
+ 	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+ 	| i370 | i860 | i960 | ia64 \
+ 	| ip2k | iq2000 \
+-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
+-	| maxq | mb | microblaze | mcore \
++	| m32r | m32rle | m68000 | m68k | m88k | maxq | mcore \
+ 	| mips | mipsbe | mipseb | mipsel | mipsle \
+ 	| mips16 \
+ 	| mips64 | mips64el \
+@@ -270,17 +268,16 @@ case $basic_machine in
+ 	| mn10200 | mn10300 \
+ 	| mt \
+ 	| msp430 \
+-	| nios | nios2 \
+ 	| ns16k | ns32k \
+ 	| or32 \
+ 	| pdp10 | pdp11 | pj | pjl \
+ 	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+ 	| pyramid \
+-	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
++	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \
+ 	| sh64 | sh64le \
+-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+-	| spu | strongarm \
++	| sparc | sparc64 | sparc64b | sparc86x | sparclet | sparclite \
++	| sparcv8 | sparcv9 | sparcv9b \
++	| strongarm \
+ 	| tahoe | thumb | tic4x | tic80 | tron \
+ 	| v850 | v850e \
+ 	| we32k \
+@@ -288,6 +285,9 @@ case $basic_machine in
+ 	| z8k)
+ 		basic_machine=$basic_machine-unknown
+ 		;;
++	m32c)
++		basic_machine=$basic_machine-unknown
++		;;
+ 	m6811 | m68hc11 | m6812 | m68hc12)
+ 		# Motorola 68HC11/12.
+ 		basic_machine=$basic_machine-unknown
+@@ -317,7 +317,7 @@ case $basic_machine in
+ 	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+ 	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+ 	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+-	| avr-* | avr32-* \
++	| avr-* \
+ 	| bfin-* | bs2000-* \
+ 	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+ 	| clipper-* | craynv-* | cydra-* \
+@@ -328,7 +328,7 @@ case $basic_machine in
+ 	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+ 	| i*86-* | i860-* | i960-* | ia64-* \
+ 	| ip2k-* | iq2000-* \
+-	| m32c-* | m32r-* | m32rle-* \
++	| m32r-* | m32rle-* \
+ 	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+ 	| m88110-* | m88k-* | maxq-* | mcore-* \
+ 	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+@@ -350,18 +350,17 @@ case $basic_machine in
+ 	| mmix-* \
+ 	| mt-* \
+ 	| msp430-* \
+-	| nios-* | nios2-* \
+ 	| none-* | np1-* | ns16k-* | ns32k-* \
+ 	| orion-* \
+ 	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+ 	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+ 	| pyramid-* \
+ 	| romp-* | rs6000-* \
+-	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
++	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | shbe-* \
+ 	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
++	| sparc-* | sparc64-* | sparc64b-* | sparc86x-* | sparclet-* \
+ 	| sparclite-* \
+-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
++	| sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
+ 	| tahoe-* | thumb-* \
+ 	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+ 	| tron-* \
+@@ -372,6 +371,8 @@ case $basic_machine in
+ 	| ymp-* \
+ 	| z8k-*)
+ 		;;
++	m32c-*)
++		;;
+ 	# Recognize the various machine names and aliases which stand
+ 	# for a CPU type and a company and sometimes even an OS.
+ 	386bsd)
+@@ -817,12 +818,6 @@ case $basic_machine in
+ 	pc532 | pc532-*)
+ 		basic_machine=ns32k-pc532
+ 		;;
+-	pc98)
+-		basic_machine=i386-pc
+-		;;
+-	pc98-*)
+-		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+-		;;
+ 	pentium | p5 | k5 | k6 | nexgen | viac3)
+ 		basic_machine=i586-pc
+ 		;;
+@@ -1125,7 +1120,7 @@ case $basic_machine in
+ 	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)
+ 		basic_machine=sh-unknown
+ 		;;
+-	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
++	sparc | sparcv8 | sparcv9 | sparcv9b)
+ 		basic_machine=sparc-sun
+ 		;;
+ 	cydra)
+@@ -1198,8 +1193,7 @@ case $os in
+ 	      | -aos* \
+ 	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+ 	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+-	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+-	      | -openbsd* | -solidbsd* \
++	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* | -openbsd* \
+ 	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+ 	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+ 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+@@ -1214,7 +1208,7 @@ case $os in
+ 	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+ 	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+ 	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+-	      | -skyos* | -haiku* | -rdos* | -toppers*)
++	      | -skyos* | -haiku* | -rdos*)
+ 	# Remember, each alternative MUST END IN *, to match a version number.
+ 		;;
+ 	-qnx*)
+@@ -1366,9 +1360,6 @@ else
+ # system, and we'll never get to this point.
+ 
+ case $basic_machine in
+-        spu-*)
+-		os=-elf
+-		;;
+ 	*-acorn)
+ 		os=-riscix1.2
+ 		;;
+@@ -1378,9 +1369,9 @@ case $basic_machine in
+ 	arm*-semi)
+ 		os=-aout
+ 		;;
+-        c4x-* | tic4x-*)
+-        	os=-coff
+-		;;
++    c4x-* | tic4x-*)
++        os=-coff
++        ;;
+ 	# This must come before the *-dec entry.
+ 	pdp10-*)
+ 		os=-tops20
+diff --git a/config/ltmain.sh b/config/ltmain.sh
+index c715b59..06823e0 100644
+--- a/config/ltmain.sh
++++ b/config/ltmain.sh
+@@ -43,7 +43,7 @@ EXIT_FAILURE=1
+ 
+ PROGRAM=ltmain.sh
+ PACKAGE=libtool
+-VERSION="1.5.22 Debian 1.5.22-4"
++VERSION=1.5.22
+ TIMESTAMP=" (1.1220.2.365 2005/12/18 22:14:06)"
+ 
+ # See if we are running on zsh, and set the options which allow our
+@@ -2082,10 +2082,7 @@ EOF
+ 	case $pass in
+ 	dlopen) libs="$dlfiles" ;;
+ 	dlpreopen) libs="$dlprefiles" ;;
+-	link)
+-	  libs="$deplibs %DEPLIBS%"
+-	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+-	  ;;
++	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+ 	esac
+       fi
+       if test "$pass" = dlopen; then
+@@ -3204,11 +3201,6 @@ EOF
+ 	    age="$number_minor"
+ 	    revision="$number_minor"
+ 	    ;;
+-	  *)
+-	    $echo "$modename: unknown library version type \`$version_type'" 1>&2
+-	    $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+-	    exit $EXIT_FAILURE
+-	    ;;
+ 	  esac
+ 	  ;;
+ 	no)
+diff --git a/src/configed.H b/src/configed.H
+index b4d1ebf..436bd54 100644
+--- a/src/configed.H
++++ b/src/configed.H
+@@ -17,10 +17,10 @@
+ 
+ #include    "config.h"
+ 
+-#ifndef COMPILER            /* No target compiler specified */
+-#define COMPILER            COMPILER_UNKNOWN
++#ifndef COMPILER
++#define COMPILER            MSC
+ #endif
+-#ifndef HOST_COMPILER       /* No host compiler specified   */
++#ifndef HOST_COMPILER
+ #define HOST_COMPILER       COMPILER
+ #endif
+ 
+diff --git a/src/internal.H b/src/internal.H
+index 5e1c19f..94b5a5a 100644
+--- a/src/internal.H
++++ b/src/internal.H
+@@ -96,7 +96,7 @@
+ #define OP_LPA          2           /* (    */
+ /* The following are unary.     */
+ #define FIRST_UNOP      OP_PLU      /* First unary operator         */
+-#define OP_PLU          3           /* +    */ 
++#define OP_PLU          3           /* +    */
+ #define OP_NEG          4           /* -    */
+ #define OP_COM          5           /* ~    */
+ #define OP_NOT          6           /* !    */
+@@ -324,7 +324,7 @@ extern struct std_limits_ {
+         int     inc_nest;           /* Least maximum of include nest*/
+         long    n_macro;            /* Least maximum of num of macro*/
+         long    line_num;           /* Maximum source line number   */
+-} std_limits;    
++} std_limits;
+ /* The boolean flags specified by the execution options.    */
+ extern struct option_flags_ {
+         int     c;                  /* -C option (keep comments)    */
+@@ -503,6 +503,8 @@ extern int      (* mcpp_fputc)( int c, OUTDEST od),
+                 (* mcpp_fputs)( const char * s, OUTDEST od),
+                 (* mcpp_fprintf)( OUTDEST od, const char * format, ...);
+ 
++extern void     (*g_report_include)(FILE *, const char *, const char *, const char *);
++
+ /* system.c */
+ extern void     do_options( int argc, char ** argv, char ** in_pp
+         , char ** out_pp);
+diff --git a/src/main.c b/src/main.c
+index a438894..b892f81 100644
+--- a/src/main.c
++++ b/src/main.c
+@@ -334,7 +334,7 @@ int     main
+ #endif
+ (
+     int argc,
+-    char ** argv
++    const char ** argv
+ )
+ {
+     char *  in_file = NULL;
+diff --git a/src/main_libmcpp.c b/src/main_libmcpp.c
+index 7163925..d266c92 100644
+--- a/src/main_libmcpp.c
++++ b/src/main_libmcpp.c
+@@ -3,7 +3,7 @@
+ #include "mcpp_lib.h"
+ 
+ int
+-main (int argc, char *argv[])
++main (int argc, const char *argv[])
+ {
+     return mcpp_lib_main (argc, argv);
+ }
+diff --git a/src/mcpp_lib.def b/src/mcpp_lib.def
+index c95f440..b3c10e9 100644
+--- a/src/mcpp_lib.def
++++ b/src/mcpp_lib.def
+@@ -5,3 +5,4 @@ EXPORTS
+ 	mcpp_set_out_func
+ 	mcpp_use_mem_buffers
+ 	mcpp_get_mem_buffer
++	mcpp_set_report_include_callback
+diff --git a/src/mcpp_lib.h b/src/mcpp_lib.h
+index 4827f0a..cc5d993 100644
+--- a/src/mcpp_lib.h
++++ b/src/mcpp_lib.h
+@@ -1,3 +1,4 @@
++// # Modifications Copyright (c) Contributors to the Open 3D Engine Project, SPDX-License-Identifier: Apache-2.0 OR MIT
+ /* mcpp_lib.h: declarations of libmcpp exported (visible) functions */
+ #ifndef _MCPP_LIB_H
+ #define _MCPP_LIB_H
+@@ -10,7 +11,7 @@
+             || __MINGW64__
+ #if     DLL_EXPORT || (__CYGWIN__ && PIC)
+ #define DLL_DECL    __declspec( dllexport)
+-#elif   DLL_IMPORT
++#elif   MCPP_DLL_IMPORT
+ #define DLL_DECL    __declspec( dllimport)
+ #else
+ #define DLL_DECL
+@@ -19,13 +20,31 @@
+ #define DLL_DECL
+ #endif
+ 
+-extern DLL_DECL int     mcpp_lib_main( int argc, char ** argv);
+-extern DLL_DECL void    mcpp_reset_def_out_func( void);
+-extern DLL_DECL void    mcpp_set_out_func(
+-                    int (* func_fputc)  ( int c, OUTDEST od),
+-                    int (* func_fputs)  ( const char * s, OUTDEST od),
+-                    int (* func_fprintf)( OUTDEST od, const char * format, ...)
+-                    );
+-extern DLL_DECL void    mcpp_use_mem_buffers( int tf);
+-extern DLL_DECL char *  mcpp_get_mem_buffer( OUTDEST od);
++#include <stdio.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++    extern DLL_DECL int     mcpp_lib_main(int argc, const char ** argv);
++    extern DLL_DECL void    mcpp_reset_def_out_func(void);
++    extern DLL_DECL void    mcpp_set_out_func(
++                        int (* func_fputc)  ( int c, MCPP_OUTDEST od),
++                        int (* func_fputs)  ( const char * s, MCPP_OUTDEST od),
++                        int (* func_fprintf)(MCPP_OUTDEST od, const char * format, ...)
++                        );
++    extern DLL_DECL void    mcpp_use_mem_buffers( int tf);
++    extern DLL_DECL char *  mcpp_get_mem_buffer(MCPP_OUTDEST od);
++
++    extern DLL_DECL void    mcpp_set_report_include_callback(
++                        void(*report_include)(FILE * fp,               /* Open file pointer    */
++                                              const char *  src_dir,   /* Directory of source  */
++                                              const char *  filename,  /* Name of the file     */
++                                              const char *  fullname)  /* Full path            */
++    );
++
++#ifdef __cplusplus
++}
++#endif
++
+ #endif  /* _MCPP_LIB_H  */
+diff --git a/src/mcpp_out.h b/src/mcpp_out.h
+index 02ba2aa..eb28660 100644
+--- a/src/mcpp_out.h
++++ b/src/mcpp_out.h
+@@ -1,13 +1,23 @@
+ /* mcpp_out.h: declarations of OUTDEST data types for MCPP  */
++// # Modifications Copyright (c) Contributors to the Open 3D Engine Project, SPDX-License-Identifier: Apache-2.0 OR MIT
+ #ifndef _MCPP_OUT_H
+ #define _MCPP_OUT_H
+ 
+ /* Choices for output destination */
+ typedef enum {
+-    OUT,                        /* ~= fp_out    */
+-    ERR,                        /* ~= fp_err    */
+-    DBG,                        /* ~= fp_debug  */
+-    NUM_OUTDEST
+-} OUTDEST;
++    MCPP_OUT,                        /* ~= fp_out    */
++    MCPP_ERR,                        /* ~= fp_err    */
++    MCPP_DBG,                        /* ~= fp_debug  */
++    MCPP_NUM_OUTDEST
++} MCPP_OUTDEST;
++
++// O3DE: keep build compatibility with MCPP
++#ifndef MCPP_DONT_USE_SHORT_NAMES
++ #define OUT MCPP_OUT
++ #define ERR MCPP_ERR
++ #define DBG MCPP_DBG
++ #define NUM_OUTDEST MCPP_NUM_OUTDEST
++ #define OUTDEST MCPP_OUTDEST
++#endif
+ 
+ #endif  /* _MCPP_OUT_H  */
+diff --git a/src/noconfig.H b/src/noconfig.H
+index 6b634fe..6482967 100644
+--- a/src/noconfig.H
++++ b/src/noconfig.H
+@@ -15,18 +15,18 @@
+  */
+ 
+ /* Define target operating-system.  */
+-#define SYSTEM              SYS_FREEBSD
++#define SYSTEM              SYS_WIN
+ 
+ /* Define target compiler.          */
+ #ifndef COMPILER
+-#define COMPILER            INDEPENDENT /* compiler-independent-build   */
++#define COMPILER            MSC /* compiler-independent-build   */
+ #endif
+ 
+ /* Define host operating-system.    */
+ #define HOST_SYSTEM         SYSTEM
+ 
+ /* Define host compiler.            */
+-#define HOST_COMPILER       GNUC
++#define HOST_COMPILER       COMPILER
+ 
+ /* Version message.                 */
+ /* "MCPP V.2.* (200y/mm) compiled by " precedes VERSION_MSG */
+diff --git a/src/support.c b/src/support.c
+index c57eaef..909be89 100644
+--- a/src/support.c
++++ b/src/support.c
+@@ -364,6 +364,19 @@ void    mcpp_set_out_func(
+ }
+ #endif
+ 
++void (*g_report_include)(FILE *, const char *, const char *, const char *);
++
++void mcpp_set_report_include_callback(
++    void(*report_include)(
++        FILE * fp,               /* Open file pointer    */
++        const char *  src_dir,   /* Directory of source  */
++        const char *  filename,  /* Name of the file     */
++        const char *  fullname)  /* Full path            */
++)
++{
++    g_report_include = report_include;
++}
++
+ int     get_unexpandable(
+     int     c,                              /* First char of token  */
+     int     diag                            /* Flag of diagnosis    */
+@@ -636,7 +649,7 @@ static void scan_id(
+         if (mcpp_mode == STD && c == '\\' && stdc2) {
+             int     cnt;
+             char *  tp = bp;
+-            
++
+             if ((c = get_ch()) == 'u') {
+                 cnt = 4;
+             } else if (c == 'U') {
+@@ -1384,7 +1397,7 @@ static char *   scan_op(
+             } else {                                    /* .        */
+                 openum = OP_1;
+             }
+-        } else {    
++        } else {
+             openum = OP_1;
+         }
+         break;
+@@ -1722,6 +1735,7 @@ com_start:
+                     sp -= 2;
+                     while (*sp != '\n')     /* Until end of line    */
+                         mcpp_fputc( *sp++, OUT);
++                    mcpp_fputc('\n', OUT);
+                 }
+                 goto  end_line;
+             default:                        /* Not a comment        */
+@@ -1821,7 +1835,7 @@ static char *   read_a_comment(
+     if (keep_spaces) {
+         saved_sp = sp - 2;          /* '-2' for beginning / and *   */
+         *sizp = 0;
+-    }        
++    }
+     if (keep_comments)                      /* If writing comments  */
+         mcpp_fputs( "/*", OUT);             /* Write the initializer*/
+     c = *sp++;
+@@ -1911,7 +1925,7 @@ static char *   get_line(
+ /*
+  * ANSI (ISO) C: translation phase 1, 2.
+  * Get the next logical line from source file.
+- * Convert [CR+LF] to [LF]. 
++ * Convert [CR+LF] to [LF].
+  */
+ {
+ #if COMPILER == INDEPENDENT
+diff --git a/src/system.c b/src/system.c
+index 4759469..5cd549a 100644
+--- a/src/system.c
++++ b/src/system.c
+@@ -303,7 +303,7 @@ static char *   mkdep_mt;               /* Argument of -MT option   */
+ /* sharp_filename is filename for #line line, used only in cur_file()   */
+ static char *   sharp_filename = NULL;
+ static char *   argv0;      /* argv[ 0] for usage() and version()   */
+-static int      ansi;           /* __STRICT_ANSI__ flag for GNUC    */ 
++static int      ansi;           /* __STRICT_ANSI__ flag for GNUC    */
+ static int      compat_mode;
+                 /* "Compatible" mode of recursive macro expansion   */
+ #define MAX_ARCH_LEN    16
+@@ -530,7 +530,7 @@ plus:
+                 compat_mode = TRUE;     /* 'compatible' mode        */
+                 mcpp_mode = STD;
+             }
+-            else 
++            else
+                 usage( opt);
+             standard = (mcpp_mode == STD || mcpp_mode == POST_STD);
+             if (old_mode != STD && old_mode != mcpp_mode)
+@@ -837,7 +837,7 @@ plus:
+             /* Fall through */
+         case 'k':
+             option_flags.k = TRUE;
+-            /* Keep white spaces of input lines as they are */ 
++            /* Keep white spaces of input lines as they are */
+             break;
+ 
+ #if COMPILER == GNUC
+@@ -1739,7 +1739,7 @@ static void def_a_macro(
+     skip_nl();                      /* Clear the appended <newline> */
+ }
+ 
+-static void     chk_opts( 
++static void     chk_opts(
+     int     sflag,      /* Flag of Standard or post-Standard mode   */
+     int     trad                    /* -traditional (GCC only)      */
+ )
+@@ -2239,7 +2239,7 @@ static void set_sys_dirs(
+     set_a_dir( "/usr/local/include");
+ #endif
+ 
+-#ifdef  C_INCLUDE_DIR1 
++#ifdef  C_INCLUDE_DIR1
+     set_a_dir( C_INCLUDE_DIR1);
+ #endif
+ #ifdef  C_INCLUDE_DIR2
+@@ -2301,7 +2301,7 @@ static void set_a_dir(
+ #if SYSTEM == SYS_MAC
+         to_search_framework = &incdir[ framework_pos];
+ #endif
+-        max_inc *= 2;                   
++        max_inc *= 2;
+     }
+ 
+     if (dirname == NULL)
+@@ -2392,7 +2392,7 @@ static char *   norm_dir(
+         if (! norm_name && option_flags.v)
+             mcpp_fprintf( ERR, "Invalid header map file \"%s\" is ignored\n"
+                     , dirname);
+-    } else 
++    } else
+ #endif
+     {
+         norm_name = norm_path( dirname, NULL, FALSE, FALSE);
+@@ -2642,7 +2642,7 @@ static char *   norm_path(
+             } else {                                /* Impossible   */
+                 break;
+             }
+-        } else {                                    /* Impossible   */ 
++        } else {                                    /* Impossible   */
+             break;
+         }
+     }
+@@ -2769,7 +2769,7 @@ static void init_gcc_macro( void)
+                 && scan_token( skip_ws(), (tp = work_buf, &tp), work_end)
+                         == NAM
+                     && str_eq( work_buf, "define")) {
+-                defp = do_define( TRUE, nargs);     /* Ignore re-definition */ 
++                defp = do_define( TRUE, nargs);     /* Ignore re-definition */
+             }
+             skip_nl();
+         }
+@@ -2981,7 +2981,7 @@ void    put_depend(
+ }
+ 
+ static char *   md_init(
+-    const char *    filename,   /* The source file name             */ 
++    const char *    filename,   /* The source file name             */
+     char *  output              /* Output to dependency file        */
+ )
+ /*
+@@ -3288,7 +3288,7 @@ static int  has_directory(
+ )
+ /*
+  * If a directory is found in the 'source' filename string (i.e. "includer"),
+- * the directory part of the string is copied to 'directory' and 
++ * the directory part of the string is copied to 'directory' and
+  * has_directory() returns TRUE.
+  * Else, nothing is copied and it returns FALSE.
+  */
+@@ -3320,7 +3320,7 @@ static int  is_full_path(
+ #if SYS_FAMILY == SYS_UNIX
+     if (path[0] == PATH_DELIM)
+ #elif   SYS_FAMILY == SYS_WIN
+-    if ((path[1] == ':' && path[2] == PATH_DELIM)   /* "C:/path"    */
++    if ((path[1] == ':' && (path[2] == PATH_DELIM || path[2] == '\\'))   /* "C:/path"    */
+             || path[0] == PATH_DELIM)       /* Root dir of current drive    */
+ #elif   1
+ /* For other systems you should write code here.    */
+@@ -3432,7 +3432,7 @@ search:
+         return  FALSE;
+     if (standard && included( fullname))        /* Once included    */
+         goto  true;
+-        
++
+     if ((max_open != 0 && max_open <= include_nest)
+                             /* Exceed the known limit of open files */
+             || ((fp = fopen( fullname, "r")) == NULL && errno == EMFILE)) {
+@@ -3462,7 +3462,7 @@ search:
+         }
+         if (max_open == 0)      /* Remember the limit of the system */
+             max_open = include_nest;
+-    } else if (fp == NULL)                  /* No read permission   */ 
++    } else if (fp == NULL)                  /* No read permission   */
+         goto  false;
+     /* Truncate buffer of the includer to save memory   */
+     len = (int) (file->bptr - file->buffer);
+@@ -3480,6 +3480,8 @@ search:
+      * Note: inc_dirp is restored to the parent includer's directory
+      *   by get_ch() when the current includer is finished.
+      */
++    if (g_report_include)
++        g_report_include(fp, src_dir, filename, fullname);
+     infile->dirp = inc_dirp = dirp;
+ #if 0   /* This part is only for debugging  */
+     chk_dirp( dirp);
+@@ -3762,7 +3764,7 @@ static int      search_framework(
+             return  TRUE;
+     }
+ 
+-    *cp2 = PATH_DELIM;      /* Restore original include file format */ 
++    *cp2 = PATH_DELIM;      /* Restore original include file format */
+ 
+     return  FALSE;
+ }
+@@ -3858,6 +3860,28 @@ static int  chk_dirp(
+ }
+ #endif
+ 
++char* mincs_ifnotnull(char* p1, char* p2)
++{
++    if (!p1) return p2;
++    if (!p2) return p1;
++    return p1 < p2 ? p1 : p2;
++}
++
++/* extract directory part of a file path */
++static char g_space[1024];
++char * dir_of(const char* path)
++{
++    const char * lastsep = mincs_ifnotnull(strrchr(path, PATH_DELIM),
++                                           strrchr(path, '\\'));
++    if (!lastsep) return NULL;
++    if (lastsep - path >= 1024)
++        cfatal("path too long encountered. %s", path, 0L, NULL);
++
++    strncpy(g_space, path, lastsep - path + 1);
++    g_space[lastsep - path + 1] = 0;
++    return g_space;
++}
++
+ void    sharp(
+     FILEINFO *  sharp_file,
+     int         flag        /* Flag to append to the line for GCC   */
+@@ -3910,17 +3934,34 @@ static void cur_file(
+ 
+     if (mcpp_debug & MACRO_CALL) {  /* In macro notification mode   */
+         if (sharp_file)                         /* Main input file  */
+-            name = file->filename;
++            name = file->full_fname;
+         else                /* Output full-path-list, normalized    */
+             name = cur_fullname;
+     } else {                /* Usually, the path not "normalized"   */
+         if (sharp_file) {                       /* Main input file  */
+             name = file->filename;
+         } else if (str_eq( file->filename, file->real_fname)) {
+-            sprintf( work_buf, "%s%s", *(file->dirp), cur_fname);
+-            name = work_buf;
++            name = file->full_fname; // O3DE: absolute paths required
+         } else {            /* Changed by '#line fname' directive   */
+-            name = file->filename;
++            if (!is_full_path(file->filename)) {     // O3DE: this block does the best it can to get real full paths.
++                name = dir_of(cur_fullname);  // extract first part of path
++                if (!name)  // no directory found in cur_fullname (weird case)
++                    name = file->filename;
++                else {
++                    sprintf( work_buf, "%s%s", name, file->filename);
++                    FILE* reachable = fopen(work_buf, "r");
++                    if (reachable) {
++                        name = norm_path(null, work_buf, FALSE, FALSE);
++                        fclose(reachable);
++                    } else {  // non reachable file encountered
++                        name = file->filename;  // input verbatim
++                    }
++                }
++                if (strlen(name) == 0)
++                    name = file->filename;  // as is
++            } else {  // absolute path already
++                name = file->filename;
++            }
+         }
+     }
+     if (sharp_filename == NULL || ! str_eq( name, sharp_filename)) {
+diff --git a/src/testmain.c b/src/testmain.c
+index 33e47b3..ce3e00d 100644
+--- a/src/testmain.c
++++ b/src/testmain.c
+@@ -13,7 +13,7 @@
+ 
+ #include "mcpp_lib.h"
+ 
+-int main(int argc, char *argv[])
++int main(int argc, const char *argv[])
+ {
+     int     i, j;
+     char ** tmp_argv;

+ 154 - 0
package-system/mcpp/visualc.mak

@@ -0,0 +1,154 @@
+# makefile to compile MCPP version 2.7.1 and later for Visual C / nmake
+#       2008/11 kmatsui
+# You must first edit BINDIR, LIBDIR and INCDIR according to your system.
+# To make compiler-independent-build of MCPP do:
+#       nmake
+# To make Visual-C-specific-build of MCPP do:
+#       nmake COMPILER=MSC
+# To re-compile MCPP using Visual-C-specific-build of MCPP do:
+#       nmake COMPILER=MSC PREPROCESSED=1
+# To link kmmalloc V.2.5.3 (malloc() package of kmatsui) or later do:
+#   (Note: Visual C 2005 and 2008 cannot coexist with kmmalloc)
+#       nmake [PREPROCESSED=1] KMMALLOC=1
+# To make mcpp.lib (subroutine-build of mcpp) do:
+#       nmake MCPP_LIB=1 mcpplib
+#       nmake MCPP_LIB=1 mcpplib_install
+# To make testmain.c (sample to use mcpp.lib) against mcpp.lib do
+#   (add 'DLL_IMPORT=1' to link against the DLL):
+#       nmake [OUT2MEM=1] testmain
+#       nmake [OUT2MEM=1] testmain_install
+# To use this Makefile in IDE of Visual C, include $(targ)_install target
+#	in $(targ) target, since the IDE can't handle install target.
+
+# This is a modified copy of //lyengine/3rdPartySource/mcpp/mcpp-2.7.2/noconfig/visualc.mak
+# Modifications Copyright (c) Contributors to the Open 3D Engine Project, SPDX-License-Identifier: Apache-2.0 OR MIT
+
+NAME = mcpp
+
+CC = cl
+CFLAGS = $(CFLAGS) -Za -c /favor:AMD64 #-Zi
+	# Add -Zi for debugging on Visual C / IDE
+LINKFLAGS = -Fe$(NAME) /MACHINE:X64 #-Zi
+CPPFLAGS = $(CPPFLAGS) -D_CRT_SECURE_NO_DEPRECATE # -Za
+	# -D_CRT_SECURE_NO_DEPRECATE for Visual C 2005, 2008
+	# -Za should not be specified for compiler-independent-built MCPP
+
+!if "$(COMPILER)"=="MSC"
+CPPFLAGS = $(CPPFLAGS) -DCOMPILER=MSC
+# BINDIR : Adjust to your system.
+#	for Visual C 2003
+#BINDIR = "$(MSVCDIR)"\bin
+#	for Visual C 2005, 2008
+BINDIR = "$(VCINSTALLDIR)"\bin
+!else
+# compiler-independent-build: use compiler-independent directory
+BINDIR = \PUB\bin
+!endif
+
+!ifdef KMMALLOC
+MEM_MACRO = -DKMMALLOC -D_MEM_DEBUG -DXMALLOC
+MEMLIB = kmmalloc_debug.lib
+!else
+MEM_MACRO =
+MEMLIB =
+!endif
+
+OBJS = main.obj directive.obj eval.obj expand.obj support.obj system.obj \
+        mbchar.obj
+
+$(NAME).exe : $(OBJS)
+	$(CC) $(LINKFLAGS) $(OBJS) $(MEMLIB)
+#install :
+# Visual C++ / IDE "makefile project" does not have "make install" command
+#	copy /b $(NAME).exe $(BINDIR)\$(NAME).exe
+
+!ifdef PREPROCESSED
+# make a "pre-preprocessed" header file to recompile MCPP with MCPP.
+mcpp.H	: system.H internal.H
+	$(BINDIR)\$(NAME) $(CPPFLAGS) $(LANG) $(MEM_MACRO) preproc.c mcpp.H
+$(OBJS) : mcpp.H
+system.H: noconfig.H
+!else
+$(OBJS) : noconfig.H
+main.obj directive.obj eval.obj expand.obj support.obj system.obj mbchar.obj: \
+        system.H internal.H
+!endif
+
+!ifdef PREPROCESSED
+.c.obj	:
+	$(BINDIR)\$(NAME) -DPREPROCESSED $(CPPFLAGS) $< $(<B).i
+	$(CC) $(CFLAGS) -TC $(<B).i
+!else
+.c.obj	:
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(MEM_MACRO) $<
+!endif
+
+clean	:
+	-del *.obj *.i mcpp.H *.exe *.lib *.dll *.exp *.so
+
+!ifdef	MCPP_LIB
+#LIBDIR = "$(MSVCDIR)"\lib
+LIBDIR = "$(VCINSTALLDIR)"\lib
+INCDIR = "$(VCINSTALLDIR)"\include
+CFLAGS = $(CFLAGS) -DMCPP_LIB
+
+mcpplib: mcpplib_lib mcpplib_dll
+# To use in Visual C IDE
+#mcpplib: mcpplib_lib mcpplib_dll mcpplib_install
+
+# Debug mode: Do 'nmake DEBUG=1 ...'
+!ifdef DEBUG
+CFLAGS = $(CFLAGS) -MDd -D_DEBUG
+#LIBSUFFIX = d
+!else
+CFLAGS = $(CFLAGS) -O2 -MD -DNDEBUG
+!endif
+
+mcpplib_lib:	$(OBJS)
+	lib -out:mcpp$(LIBSUFFIX).lib $(OBJS)
+
+# DLL
+DLL_VER = 0
+SOBJS = main.so directive.so eval.so expand.so support.so system.so mbchar.so
+.SUFFIXES: .so
+.c.so	:
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(MEM_MACRO) -DDLL_EXPORT -TC -Fo$*.so $<
+mcpplib_dll:	$(SOBJS)
+	$(CC) -LD -Femcpp$(DLL_VER)$(LIBSUFFIX) $(SOBJS) $(MEMLIB) /MACHINE:X64
+mcpplib_install:
+	copy mcpp$(LIBSUFFIX).lib $(LIBDIR)
+	copy mcpp$(DLL_VER)$(LIBSUFFIX).lib $(LIBDIR)
+	copy mcpp$(DLL_VER)$(LIBSUFFIX).dll $(BINDIR)
+	copy mcpp_lib.h $(INCDIR)
+	copy mcpp_out.h $(INCDIR)
+	$(CC) main_libmcpp.c -Fe$(NAME).exe 	\
+			$(LIBDIR)\mcpp$(DLL_VER)$(LIBSUFFIX).lib	\
+			-link -force:multiple /MACHINE:X64
+	copy $(NAME).exe $(BINDIR)
+mcpplib_uninstall:
+	del $(LIBDIR)\mcpp$(LIBSUFFIX).lib	\
+			$(LIBDIR)\mcpp$(DLL_VER)$(LIBSUFFIX).lib	\
+			$(BINDIR)\mcpp$(DLL_VER)$(LIBSUFFIX).dll
+	del $(BINDIR)\$(NAME).exe
+	del $(INCDIR)\mcpp*
+!endif
+
+# use mcpp as a subroutine from testmain.c
+!ifdef	DLL_IMPORT
+CFLAGS = $(CFLAGS) -DDLL_IMPORT
+LINKLIB = mcpp$(DLL_VER)$(LIBSUFFIX).lib
+!else
+LINKLIB = mcpp$(LIBSUFFIX).lib
+!endif
+TMAIN_LINKFLAGS = testmain.obj -Fetestmain.exe $(LIBDIR)\$(LINKLIB) \
+			-link -force:multiple /MACHINE:X64
+!ifdef	OUT2MEM
+# output to memory buffer
+CFLAGS = $(CFLAGS) -DOUT2MEM
+!endif
+testmain	: testmain.obj
+	$(CC) $(TMAIN_LINKFLAGS)
+testmain_install	:
+	copy testmain.exe $(BINDIR)
+testmain_uninstall	:
+	del $(BINDIR)\testmain.exe

+ 1 - 0
package-system/mikkelsen/.gitignore

@@ -0,0 +1 @@
+build/*

+ 31 - 0
package-system/mikkelsen/CMakeLists.txt

@@ -0,0 +1,31 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+cmake_minimum_required(VERSION 3.17)
+
+project(mikkelsen)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+add_library(
+    ${CMAKE_PROJECT_NAME} STATIC
+    mikktspace.h
+    mikktspace.cpp
+)
+
+set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES PUBLIC_HEADER mikktspace.h)
+
+include(../../Scripts/cmake/package.cmake)
+package_install(
+    NAME ${CMAKE_PROJECT_NAME}
+    VERSION 1.0.0.4
+    URL "https://github.com/mmikk/MikkTSpace"
+    LICENSE Zlib
+    LICENSE_FILE LICENSE.txt
+    INCLUDE_SUBDIR ${CMAKE_PROJECT_NAME}
+)

+ 17 - 0
package-system/mikkelsen/LICENSE.txt

@@ -0,0 +1,17 @@
+Copyright (C) 2011 by Morten S. Mikkelsen
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

+ 88 - 0
package-system/mikkelsen/build_package_image.py

@@ -0,0 +1,88 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+import argparse
+import os
+import platform
+import subprocess
+import sys
+
+parser = argparse.ArgumentParser(description='Builds this package')
+parser.add_argument('--platform', default=platform.system().lower(), required=False, help=f'Platform to build (defaults to \"{platform.system().lower()}\")')
+args = parser.parse_args()
+
+this_dir = os.path.dirname(os.path.realpath(__file__))
+cmake_scripts_path = os.path.abspath(os.path.join(this_dir, '../../Scripts/cmake'))
+
+ly_3rdparty_path = os.getenv('LY_3RDPARTY_PATH')
+
+folder_names = { 
+    #system-name  cmake generation, cmake build
+    'mac'       : ([
+        '-G', 'Xcode'
+    ], []),
+    'ios'       : ([
+        '-G', 'Xcode',
+        f'-DCMAKE_TOOLCHAIN_FILE={cmake_scripts_path}/Platform/iOS/Toolchain_ios.cmake',
+        '-DPACKAGE_PLATFORM=ios'
+    ], [
+        '--',
+        '-destination generic/platform=iOS'
+    ]),
+    'linux'     : ([
+        '-G', 'Ninja Multi-Config',
+        '-DCMAKE_C_COMPILER=clang-6.0', 
+        '-DCMAKE_CXX_COMPILER=clang++-6.0'
+    ], []),
+    'windows'   : ([
+        '-G', 'Visual Studio 15 2017',
+        '-Ax64', '-Thost=x64'
+    ], []),
+    'android'   : ([
+        '-G', 'Ninja Multi-Config',
+        f'-DCMAKE_TOOLCHAIN_FILE={cmake_scripts_path}/Platform/Android/Toolchain_android.cmake',
+        '-DANDROID_ABI=arm64-v8a',
+        '-DANDROID_ARM_MODE=arm',
+        '-DANDROID_ARM_NEON=FALSE',
+        '-DANDROID_NATIVE_API_LEVEL=21',
+        f'-DLY_NDK_DIR={ly_3rdparty_path}/android-ndk/r21d',
+        '-DPACKAGE_PLATFORM=android'
+    ], []) # Android needs to have ninja in the path
+}
+
+# intentionally generate a keyerror if its not a good platform:
+cmake_generation, cmake_build = folder_names[args.platform]
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+package_name = os.path.basename(script_dir) 
+build_dir = os.path.join(script_dir, 'build', args.platform)
+os.makedirs(build_dir, exist_ok=True)
+
+# generate
+generate_call = ['cmake', '-S.', f'-B{build_dir}', f'-DCMAKE_INSTALL_PREFIX=../../package-system/{package_name}-{args.platform}/']
+if cmake_generation:
+    generate_call += cmake_generation
+result_value = subprocess.run(generate_call, shell=False, cwd=script_dir)
+if result_value.returncode != 0:
+    sys.exit(result_value.returncode)
+
+# build debug
+build_call =['cmake', '--build', build_dir, '--config', 'debug', '--target', 'install']
+if cmake_build:
+    build_call += cmake_build
+print(build_call)
+result_value = subprocess.run(build_call, shell=False, cwd=script_dir)
+if result_value.returncode != 0:
+    sys.exit(result_value.returncode)
+
+# build release
+build_call =['cmake', '--build', build_dir, '--config', 'release', '--target', 'install']
+if cmake_build:
+    build_call += cmake_build
+result_value = subprocess.run(build_call, shell=False, cwd=script_dir)
+sys.exit(result_value.returncode)

+ 1966 - 0
package-system/mikkelsen/mikktspace.cpp

@@ -0,0 +1,1966 @@
+/**
+ * This is a modified version of Morten S. Mikkelsen's mikktspace.cpp.
+ * The original version was renamed to mikktspace_original.cpp.
+ *
+ * Changes:
+ *
+ * 2013/10/23  Sergey Sokov
+ *     DegenEpilogue() was changed to handle degenerate triangles
+ *     faster than O(N^2) - now it's O(N log N)).
+ */
+
+/**
+ *  Copyright (C) 2011 by Morten S. Mikkelsen
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty.  In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ *  2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ *  3. This notice may not be removed or altered from any source distribution.
+ */
+
+#if !defined(_PREFAST_)
+#	define PREFAST_ASSUME(cond)
+#endif
+
+#include "mikktspace.h"
+#include <algorithm>    // std::stable_sort
+#include <assert.h>
+#include <math.h>
+#include <float.h>
+#include <string.h>
+
+#pragma warning(disable: 6385 6386)
+
+#define TFALSE		0
+#define TTRUE		1
+
+#ifndef M_PI
+#define M_PI	3.1415926535897932384626433832795
+#endif
+
+#define INTERNAL_RND_SORT_SEED		39871946
+
+// internal structure
+typedef struct
+{
+	float x, y, z;
+} SVec3;
+
+static tbool			veq( const SVec3 v1, const SVec3 v2 )
+{
+	return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
+}
+
+static SVec3		vadd( const SVec3 v1, const SVec3 v2 )
+{
+	SVec3 vRes;
+
+	vRes.x = v1.x + v2.x;
+	vRes.y = v1.y + v2.y;
+	vRes.z = v1.z + v2.z;
+
+	return vRes;
+}
+
+
+static SVec3		vsub( const SVec3 v1, const SVec3 v2 )
+{
+	SVec3 vRes;
+
+	vRes.x = v1.x - v2.x;
+	vRes.y = v1.y - v2.y;
+	vRes.z = v1.z - v2.z;
+
+	return vRes;
+}
+
+static SVec3		vscale(const float fS, const SVec3 v)
+{
+	SVec3 vRes;
+
+	vRes.x = fS * v.x;
+	vRes.y = fS * v.y;
+	vRes.z = fS * v.z;
+
+	return vRes;
+}
+
+static float			LengthSquared( const SVec3 v )
+{
+	return v.x*v.x + v.y*v.y + v.z*v.z;
+}
+
+static float			Length( const SVec3 v )
+{
+	return sqrtf(LengthSquared(v));
+}
+
+static SVec3		Normalize( const SVec3 v )
+{
+	return vscale(1 / Length(v), v);
+}
+
+static float		vdot( const SVec3 v1, const SVec3 v2)
+{
+	return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
+}
+
+
+static tbool NotZero(const float fX)
+{
+	// could possibly use FLT_EPSILON instead
+	return fabsf(fX) > FLT_MIN;
+}
+
+static tbool VNotZero(const SVec3 v)
+{
+	// might change this to an epsilon based test
+	return NotZero(v.x) || NotZero(v.y) || NotZero(v.z);
+}
+
+
+
+typedef struct
+{
+	int iNrFaces;
+	int * pTriMembers;
+} SSubGroup;
+
+typedef struct
+{
+	int iNrFaces;
+	int * pFaceIndices;
+	int iVertexRepresentitive;
+	tbool bOrientPreservering;
+} SGroup;
+
+//
+#define MARK_DEGENERATE				1
+#define QUAD_ONE_DEGEN_TRI			2
+#define GROUP_WITH_ANY				4
+#define ORIENT_PRESERVING			8
+
+
+
+typedef struct
+{
+	int FaceNeighbors[3];
+	SGroup * AssignedGroup[3];
+
+	// normalized first order face derivatives
+	SVec3 vOs, vOt;
+	float fMagS, fMagT;	// original magnitudes
+
+	// determines if the current and the next triangle are a quad.
+	int iOrgFaceNumber;
+	int iFlag, iTSpacesOffs;
+	unsigned char vert_num[4];
+} STriInfo;
+
+typedef struct
+{
+	SVec3 vOs;
+	float fMagS;
+	SVec3 vOt;
+	float fMagT;
+	int iCounter;	// this is to average back into quads.
+	tbool bOrient;
+} STSpace;
+
+static int GenerateInitialVerticesIndexList(STriInfo pTriInfos[], int piTriList_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn);
+static void GenerateSharedVerticesIndexList(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn);
+static void InitTriInfo(STriInfo pTriInfos[], const int piTriListIn[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn);
+static int Build4RuleGroups(STriInfo pTriInfos[], SGroup pGroups[], int piGroupTrianglesBuffer[], const int piTriListIn[], const int iNrTrianglesIn);
+static tbool GenerateTSpaces(STSpace psTspace[], const STriInfo pTriInfos[], const SGroup pGroups[],
+					 const int iNrActiveGroups, const int piTriListIn[], const float fThresCos,
+					 const SMikkTSpaceContext * pContext);
+
+static int MakeIndex(const int iFace, const int iVert)
+{
+	assert(iVert>=0 && iVert<4 && iFace>=0);
+	return (iFace<<2) | (iVert&0x3);
+}
+
+static void IndexToData(int * piFace, int * piVert, const int iIndexIn)
+{
+	piVert[0] = iIndexIn&0x3;
+	piFace[0] = iIndexIn>>2;
+}
+
+static STSpace AvgTSpace(const STSpace * pTS0, const STSpace * pTS1)
+{
+	STSpace ts_res;
+
+	// this if is important. Due to floating point precision
+	// averaging when ts0==ts1 will cause a slight difference
+	// which results in tangent space splits later on
+	if(pTS0->fMagS==pTS1->fMagS && pTS0->fMagT==pTS1->fMagT &&
+	   veq(pTS0->vOs,pTS1->vOs)	&& veq(pTS0->vOt, pTS1->vOt))
+	{
+		ts_res.fMagS = pTS0->fMagS;
+		ts_res.fMagT = pTS0->fMagT;
+		ts_res.vOs = pTS0->vOs;
+		ts_res.vOt = pTS0->vOt;
+	}
+	else
+	{
+		ts_res.fMagS = 0.5f*(pTS0->fMagS+pTS1->fMagS);
+		ts_res.fMagT = 0.5f*(pTS0->fMagT+pTS1->fMagT);
+		ts_res.vOs = vadd(pTS0->vOs,pTS1->vOs);
+		ts_res.vOt = vadd(pTS0->vOt,pTS1->vOt);
+		if( VNotZero(ts_res.vOs) ) ts_res.vOs = Normalize(ts_res.vOs);
+		if( VNotZero(ts_res.vOt) ) ts_res.vOt = Normalize(ts_res.vOt);
+	}
+
+	return ts_res;
+}
+
+
+
+static SVec3 GetPosition(const SMikkTSpaceContext * pContext, const int index);
+static SVec3 GetNormal(const SMikkTSpaceContext * pContext, const int index);
+static SVec3 GetTexCoord(const SMikkTSpaceContext * pContext, const int index);
+
+
+// degen triangles
+static void DegenPrologue(STriInfo pTriInfos[], int piTriList_out[], const int iNrTrianglesIn, const int iTotTris);
+static tbool DegenEpilogue(STSpace psTspace[], STriInfo pTriInfos[], int piTriListIn[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn, const int iTotTris);
+
+
+tbool genTangSpaceDefault(const SMikkTSpaceContext * pContext)
+{
+	return genTangSpace(pContext, 180.0f);
+}
+
+tbool genTangSpace(const SMikkTSpaceContext * pContext, const float fAngularThreshold)
+{
+	// count nr_triangles
+	int * piTriListIn = NULL, * piGroupTrianglesBuffer = NULL;
+	STriInfo * pTriInfos = NULL;
+	SGroup * pGroups = NULL;
+	STSpace * psTspace = NULL;
+	int iNrTrianglesIn = 0, f=0, t=0, i=0;
+	int iNrTSPaces = 0, iTotTris = 0, iDegenTriangles = 0, iNrMaxGroups = 0;
+	int iNrActiveGroups = 0, index = 0;
+	const int iNrFaces = pContext->m_pInterface->m_getNumFaces(pContext);
+	tbool bRes = TFALSE;
+	const float fThresCos = (const float) cos((fAngularThreshold*M_PI)/180);
+
+	// verify all call-backs have been set
+	if( pContext->m_pInterface->m_getNumFaces==NULL ||
+		pContext->m_pInterface->m_getNumVerticesOfFace==NULL ||
+		pContext->m_pInterface->m_getPosition==NULL ||
+		pContext->m_pInterface->m_getNormal==NULL ||
+		pContext->m_pInterface->m_getTexCoord==NULL )
+		return TFALSE;
+
+	// count triangles on supported faces
+	for(f=0; f<iNrFaces; f++)
+	{
+		const int verts = pContext->m_pInterface->m_getNumVerticesOfFace(pContext, f);
+		if(verts==3) ++iNrTrianglesIn;
+		else if(verts==4) iNrTrianglesIn += 2;
+	}
+	if(iNrTrianglesIn<=0) return TFALSE;
+
+	// allocate memory for an index list
+	piTriListIn = (int *) malloc(sizeof(int)*3*iNrTrianglesIn);
+	pTriInfos = (STriInfo *) malloc(sizeof(STriInfo)*iNrTrianglesIn);
+	if(piTriListIn==NULL || pTriInfos==NULL)
+	{
+		if(piTriListIn!=NULL) free(piTriListIn);
+		if(pTriInfos!=NULL) free(pTriInfos);
+		return TFALSE;
+	}
+
+	// make an initial triangle --> face index list
+	iNrTSPaces = GenerateInitialVerticesIndexList(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
+
+	// make a welded index list of identical positions and attributes (pos, norm, texc)
+	//printf("gen welded index list begin\n");
+	GenerateSharedVerticesIndexList(piTriListIn, pContext, iNrTrianglesIn);
+	//printf("gen welded index list end\n");
+
+	// Mark all degenerate triangles
+	iTotTris = iNrTrianglesIn;
+	iNrTrianglesIn = 0;
+	iDegenTriangles = 0;
+	for(t=0; t<iTotTris; t++)
+	{
+		const int i0 = piTriListIn[t*3+0];
+		const int i1 = piTriListIn[t*3+1];
+		const int i2 = piTriListIn[t*3+2];
+		const SVec3 p0 = GetPosition(pContext, i0);
+		const SVec3 p1 = GetPosition(pContext, i1);
+		const SVec3 p2 = GetPosition(pContext, i2);
+		if(veq(p0,p1) || veq(p0,p2) || veq(p1,p2))	// degenerate
+		{
+			pTriInfos[t].iFlag |= MARK_DEGENERATE;
+			++iDegenTriangles;
+		}
+	}
+	iNrTrianglesIn = iTotTris - iDegenTriangles;
+
+	// mark all triangle pairs that belong to a quad with only one
+	// good triangle. These need special treatment in DegenEpilogue().
+	// Additionally, move all good triangles to the start of
+	// pTriInfos[] and piTriListIn[] without changing order and
+	// put the degenerate triangles last.
+	DegenPrologue(pTriInfos, piTriListIn, iNrTrianglesIn, iTotTris);
+
+
+	// evaluate triangle level attributes and neighbor list
+	//printf("gen neighbors list begin\n");
+	InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn);
+	//printf("gen neighbors list end\n");
+
+
+	// based on the 4 rules, identify groups based on connectivity
+	iNrMaxGroups = iNrTrianglesIn*3;
+	pGroups = (SGroup *) malloc(sizeof(SGroup)*iNrMaxGroups);
+	piGroupTrianglesBuffer = (int *) malloc(sizeof(int)*iNrTrianglesIn*3);
+	if(pGroups==NULL || piGroupTrianglesBuffer==NULL)
+	{
+		if(pGroups!=NULL) free(pGroups);
+		if(piGroupTrianglesBuffer!=NULL) free(piGroupTrianglesBuffer);
+		free(piTriListIn);
+		free(pTriInfos);
+		return TFALSE;
+	}
+	//printf("gen 4rule groups begin\n");
+	iNrActiveGroups =
+		Build4RuleGroups(pTriInfos, pGroups, piGroupTrianglesBuffer, piTriListIn, iNrTrianglesIn);
+	//printf("gen 4rule groups end\n");
+
+	//
+
+	psTspace = (STSpace *) malloc(sizeof(STSpace)*iNrTSPaces);
+	if(psTspace==NULL)
+	{
+		free(piTriListIn);
+		free(pTriInfos);
+		free(pGroups);
+		free(piGroupTrianglesBuffer);
+		return TFALSE;
+	}
+	memset(psTspace, 0, sizeof(STSpace)*iNrTSPaces);
+	for(t=0; t<iNrTSPaces; t++)
+	{
+		psTspace[t].vOs.x=1.0f; psTspace[t].vOs.y=0.0f; psTspace[t].vOs.z=0.0f; psTspace[t].fMagS = 1.0f;
+		psTspace[t].vOt.x=0.0f; psTspace[t].vOt.y=1.0f; psTspace[t].vOt.z=0.0f; psTspace[t].fMagT = 1.0f;
+	}
+
+	// make tspaces, each group is split up into subgroups if necessary
+	// based on fAngularThreshold. Finally a tangent space is made for
+	// every resulting subgroup
+	//printf("gen tspaces begin\n");
+	bRes = GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriListIn, fThresCos, pContext);
+	//printf("gen tspaces end\n");
+
+	// clean up
+	free(pGroups);
+	free(piGroupTrianglesBuffer);
+
+	if(!bRes)	// if an allocation in GenerateTSpaces() failed
+	{
+		// clean up and return false
+		free(pTriInfos); free(piTriListIn); free(psTspace);
+		return TFALSE;
+	}
+
+
+	// degenerate quads with one good triangle will be fixed by copying a space from
+	// the good triangle to the coinciding vertex.
+	// all other degenerate triangles will just copy a space from any good triangle
+	// with the same welded index in piTriListIn[].
+	if(!DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesIn, iTotTris))
+	{
+		// clean up and return false
+		free(pTriInfos); free(piTriListIn); free(psTspace);
+		return TFALSE;
+	}
+
+	free(pTriInfos); free(piTriListIn);
+
+	index = 0;
+	for(f=0; f<iNrFaces; f++)
+	{
+		const int verts = pContext->m_pInterface->m_getNumVerticesOfFace(pContext, f);
+		if(verts!=3 && verts!=4) continue;
+
+
+		// I've decided to let degenerate triangles and group-with-anythings
+		// vary between left/right hand coordinate systems at the vertices.
+		// All healthy triangles on the other hand are built to always be either or.
+
+		/*// force the coordinate system orientation to be uniform for every face.
+		// (this is already the case for good triangles but not for
+		// degenerate ones and those with bGroupWithAnything==true)
+		bool bOrient = psTspace[index].bOrient;
+		if(psTspace[index].iCounter == 0)	// tspace was not derived from a group
+		{
+			// look for a space created in GenerateTSpaces() by iCounter>0
+			bool bNotFound = true;
+			int i=1;
+			while(i<verts && bNotFound)
+			{
+				if(psTspace[index+i].iCounter > 0) bNotFound=false;
+				else ++i;
+			}
+			if(!bNotFound) bOrient = psTspace[index+i].bOrient;
+		}*/
+
+		// set data
+		for(i=0; i<verts; i++)
+		{
+			const STSpace * pTSpace = &psTspace[index];
+			float tang[] = {pTSpace->vOs.x, pTSpace->vOs.y, pTSpace->vOs.z};
+			float bitang[] = {pTSpace->vOt.x, pTSpace->vOt.y, pTSpace->vOt.z};
+			if(pContext->m_pInterface->m_setTSpace!=NULL)
+				pContext->m_pInterface->m_setTSpace(pContext, tang, bitang, pTSpace->fMagS, pTSpace->fMagT, pTSpace->bOrient, f, i);
+			if(pContext->m_pInterface->m_setTSpaceBasic!=NULL)
+				pContext->m_pInterface->m_setTSpaceBasic(pContext, tang, pTSpace->bOrient==TTRUE ? 1.0f : (-1.0f), f, i);
+
+			++index;
+		}
+	}
+
+	free(psTspace);
+
+
+	return TTRUE;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+	float vert[3];
+	int index;
+} STmpVert;
+
+const int g_iCells = 2048;
+
+#ifdef _MSC_VER
+	#define NOINLINE __declspec(noinline)
+#else
+	#define NOINLINE __attribute__ ((noinline))
+#endif
+
+// it is IMPORTANT that this function is called to evaluate the hash since
+// inlining could potentially reorder instructions and generate different
+// results for the same effective input value fVal.
+NOINLINE int FindGridCell(const float fMin, const float fMax, const float fVal)
+{
+	const float fIndex = g_iCells * ((fVal-fMin)/(fMax-fMin));
+	const int iIndex = fIndex<0 ? 0 : ((int)fIndex);
+	return iIndex<g_iCells ? iIndex : (g_iCells-1);
+}
+
+static void MergeVertsFast(int piTriList_in_and_out[], STmpVert pTmpVert[], const SMikkTSpaceContext * pContext, const int iL_in, const int iR_in);
+static void MergeVertsSlow(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int pTable[], const int iEntries);
+static void GenerateSharedVerticesIndexListSlow(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn);
+
+static void GenerateSharedVerticesIndexList(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn)
+{
+
+	// Generate bounding box
+	int * piHashTable=NULL, * piHashCount=NULL, * piHashOffsets=NULL, * piHashCount2=NULL;
+	STmpVert * pTmpVert = NULL;
+	int iChannel=0, k=0, e=0;
+	int iMaxCount=0;
+	SVec3 vMin = GetPosition(pContext, 0), vMax = vMin, vDim;
+	float fMin, fMax;
+	for(int i=1; i<(iNrTrianglesIn*3); i++)
+	{
+		const int index = piTriList_in_and_out[i];
+
+		const SVec3 vP = GetPosition(pContext, index);
+		if(vMin.x > vP.x) vMin.x = vP.x;
+		else if(vMax.x < vP.x) vMax.x = vP.x;
+		if(vMin.y > vP.y) vMin.y = vP.y;
+		else if(vMax.y < vP.y) vMax.y = vP.y;
+		if(vMin.z > vP.z) vMin.z = vP.z;
+		else if(vMax.z < vP.z) vMax.z = vP.z;
+	}
+
+	vDim = vsub(vMax,vMin);
+	iChannel = 0;
+	fMin = vMin.x; fMax=vMax.x;
+	if(vDim.y>vDim.x && vDim.y>vDim.z)
+	{
+		iChannel=1;
+		fMin = vMin.y, fMax=vMax.y;
+	}
+	else if(vDim.z>vDim.x)
+	{
+		iChannel=2;
+		fMin = vMin.z, fMax=vMax.z;
+	}
+
+	// make allocations
+	piHashTable = (int *) malloc(sizeof(int)*iNrTrianglesIn*3);
+	piHashCount = (int *) malloc(sizeof(int)*g_iCells);
+	piHashOffsets = (int *) malloc(sizeof(int)*g_iCells);
+	piHashCount2 = (int *) malloc(sizeof(int)*g_iCells);
+
+	if(piHashTable==NULL || piHashCount==NULL || piHashOffsets==NULL || piHashCount2==NULL)
+	{
+		if(piHashTable!=NULL) free(piHashTable);
+		if(piHashCount!=NULL) free(piHashCount);
+		if(piHashOffsets!=NULL) free(piHashOffsets);
+		if(piHashCount2!=NULL) free(piHashCount2);
+		GenerateSharedVerticesIndexListSlow(piTriList_in_and_out, pContext, iNrTrianglesIn);
+		return;
+	}
+	memset(piHashCount, 0, sizeof(int)*g_iCells);
+	memset(piHashCount2, 0, sizeof(int)*g_iCells);
+
+	// count amount of elements in each cell unit
+	for(int i=0; i<(iNrTrianglesIn*3); i++)
+	{
+		const int index = piTriList_in_and_out[i];
+		const SVec3 vP = GetPosition(pContext, index);
+		const float fVal = iChannel==0 ? vP.x : (iChannel==1 ? vP.y : vP.z);
+		const int iCell = FindGridCell(fMin, fMax, fVal);
+		++piHashCount[iCell];
+	}
+
+	// evaluate start index of each cell.
+	piHashOffsets[0]=0;
+	for(k=1; k<g_iCells; k++)
+		piHashOffsets[k]=piHashOffsets[k-1]+piHashCount[k-1];
+
+	// insert vertices
+	for(int i=0; i<(iNrTrianglesIn*3); i++)
+	{
+		const int index = piTriList_in_and_out[i];
+		const SVec3 vP = GetPosition(pContext, index);
+		const float fVal = iChannel==0 ? vP.x : (iChannel==1 ? vP.y : vP.z);
+		const int iCell = FindGridCell(fMin, fMax, fVal);
+		int * pTable = NULL;
+
+		assert(piHashCount2[iCell]<piHashCount[iCell]);
+		pTable = &piHashTable[piHashOffsets[iCell]];
+		pTable[piHashCount2[iCell]] = i;	// vertex i has been inserted.
+		++piHashCount2[iCell];
+	}
+	for(k=0; k<g_iCells; k++)
+		assert(piHashCount2[k] == piHashCount[k]);	// verify the count
+	free(piHashCount2);
+
+	// find maximum amount of entries in any hash entry
+	iMaxCount = piHashCount[0];
+	for(k=1; k<g_iCells; k++)
+		if(iMaxCount<piHashCount[k])
+			iMaxCount=piHashCount[k];
+	pTmpVert = (STmpVert *) malloc(sizeof(STmpVert)*iMaxCount);
+
+
+	// complete the merge
+	for(k=0; k<g_iCells; k++)
+	{
+		// extract table of cell k and amount of entries in it
+		int * pTable = &piHashTable[piHashOffsets[k]];
+		const int iEntries = piHashCount[k];
+		if(iEntries < 2) continue;
+
+		if(pTmpVert!=NULL)
+		{
+			for(e=0; e<iEntries; e++)
+			{
+				int i = pTable[e];
+				const SVec3 vP = GetPosition(pContext, piTriList_in_and_out[i]);
+				pTmpVert[e].vert[0] = vP.x; pTmpVert[e].vert[1] = vP.y;
+				pTmpVert[e].vert[2] = vP.z; pTmpVert[e].index = i;
+			}
+			MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, 0, iEntries-1);
+		}
+		else
+			MergeVertsSlow(piTriList_in_and_out, pContext, pTable, iEntries);
+	}
+
+	if(pTmpVert!=NULL) { free(pTmpVert); }
+	free(piHashTable);
+	free(piHashCount);
+	free(piHashOffsets);
+}
+
+static void MergeVertsFast(int piTriList_in_and_out[], STmpVert pTmpVert[], const SMikkTSpaceContext * pContext, const int iL_in, const int iR_in)
+{
+	// make bbox
+	int c=0, l=0, channel=0;
+	float fvMin[3], fvMax[3];
+	float dx=0, dy=0, dz=0, fSep=0;
+	for(c=0; c<3; c++)
+	{	fvMin[c]=pTmpVert[iL_in].vert[c]; fvMax[c]=fvMin[c];	}
+	for(l=(iL_in+1); l<=iR_in; l++)
+		for(c=0; c<3; c++)
+			if(fvMin[c]>pTmpVert[l].vert[c]) fvMin[c]=pTmpVert[l].vert[c];
+			else if(fvMax[c]<pTmpVert[l].vert[c]) fvMax[c]=pTmpVert[l].vert[c];
+
+	dx = fvMax[0]-fvMin[0];
+	dy = fvMax[1]-fvMin[1];
+	dz = fvMax[2]-fvMin[2];
+
+	channel = 0;
+	if(dy>dx && dy>dz) channel=1;
+	else if(dz>dx) channel=2;
+
+	fSep = 0.5f*(fvMax[channel]+fvMin[channel]);
+
+	// terminate recursion when the separation/average value
+	// is no longer strictly between fMin and fMax values.
+	if(fSep>=fvMax[channel] || fSep<=fvMin[channel])
+	{
+		// complete the weld
+		for(l=iL_in; l<=iR_in; l++)
+		{
+			int i = pTmpVert[l].index;
+			const int index = piTriList_in_and_out[i];
+			const SVec3 vP = GetPosition(pContext, index);
+			const SVec3 vN = GetNormal(pContext, index);
+			const SVec3 vT = GetTexCoord(pContext, index);
+
+			tbool bNotFound = TTRUE;
+			int l2=iL_in, i2rec=-1;
+			while(l2<l && bNotFound)
+			{
+				const int i2 = pTmpVert[l2].index;
+				const int index2 = piTriList_in_and_out[i2];
+				const SVec3 vP2 = GetPosition(pContext, index2);
+				const SVec3 vN2 = GetNormal(pContext, index2);
+				const SVec3 vT2 = GetTexCoord(pContext, index2);
+				i2rec=i2;
+
+				//if(vP==vP2 && vN==vN2 && vT==vT2)
+				if(vP.x==vP2.x && vP.y==vP2.y && vP.z==vP2.z &&
+					vN.x==vN2.x && vN.y==vN2.y && vN.z==vN2.z &&
+					vT.x==vT2.x && vT.y==vT2.y && vT.z==vT2.z)
+					bNotFound = TFALSE;
+				else
+					++l2;
+			}
+
+			// merge if previously found
+			if(!bNotFound)
+				piTriList_in_and_out[i] = piTriList_in_and_out[i2rec];
+		}
+	}
+	else
+	{
+		int iL=iL_in, iR=iR_in;
+		assert((iR_in-iL_in)>0);	// at least 2 entries
+
+		// separate (by fSep) all points between iL_in and iR_in in pTmpVert[]
+		while(iL < iR)
+		{
+			tbool bReadyLeftSwap = TFALSE, bReadyRightSwap = TFALSE;
+			while((!bReadyLeftSwap) && iL<iR)
+			{
+				assert(iL>=iL_in && iL<=iR_in);
+				bReadyLeftSwap = !(pTmpVert[iL].vert[channel]<fSep);
+				if(!bReadyLeftSwap) ++iL;
+			}
+			while((!bReadyRightSwap) && iL<iR)
+			{
+				assert(iR>=iL_in && iR<=iR_in);
+				bReadyRightSwap = pTmpVert[iR].vert[channel]<fSep;
+				if(!bReadyRightSwap) --iR;
+			}
+			assert( (iL<iR) || !(bReadyLeftSwap && bReadyRightSwap) );
+
+			if(bReadyLeftSwap && bReadyRightSwap)
+			{
+				const STmpVert sTmp = pTmpVert[iL];
+				assert(iL<iR);
+				pTmpVert[iL] = pTmpVert[iR];
+				pTmpVert[iR] = sTmp;
+				++iL; --iR;
+			}
+		}
+
+		assert(iL==(iR+1) || (iL==iR));
+		if(iL==iR)
+		{
+			const tbool bReadyRightSwap = pTmpVert[iR].vert[channel]<fSep;
+			if(bReadyRightSwap) ++iL;
+			else --iR;
+		}
+
+		// only need to weld when there is more than 1 instance of the (x,y,z)
+		if(iL_in < iR)
+			MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL_in, iR);	// weld all left of fSep
+		if(iL < iR_in)
+			MergeVertsFast(piTriList_in_and_out, pTmpVert, pContext, iL, iR_in);	// weld all right of (or equal to) fSep
+	}
+}
+
+static void MergeVertsSlow(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int pTable[], const int iEntries)
+{
+	// this can be optimized further using a tree structure or more hashing.
+	int e=0;
+	for(e=0; e<iEntries; e++)
+	{
+		int i = pTable[e];
+		const int index = piTriList_in_and_out[i];
+		const SVec3 vP = GetPosition(pContext, index);
+		const SVec3 vN = GetNormal(pContext, index);
+		const SVec3 vT = GetTexCoord(pContext, index);
+
+		tbool bNotFound = TTRUE;
+		int e2=0, i2rec=-1;
+		while(e2<e && bNotFound)
+		{
+			const int i2 = pTable[e2];
+			const int index2 = piTriList_in_and_out[i2];
+			const SVec3 vP2 = GetPosition(pContext, index2);
+			const SVec3 vN2 = GetNormal(pContext, index2);
+			const SVec3 vT2 = GetTexCoord(pContext, index2);
+			i2rec = i2;
+
+			if(veq(vP,vP2) && veq(vN,vN2) && veq(vT,vT2))
+				bNotFound = TFALSE;
+			else
+				++e2;
+		}
+
+		// merge if previously found
+		if(!bNotFound)
+			piTriList_in_and_out[i] = piTriList_in_and_out[i2rec];
+	}
+}
+
+static void GenerateSharedVerticesIndexListSlow(int piTriList_in_and_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn)
+{
+	int iNumUniqueVerts = 0, t=0, i=0;
+	for(t=0; t<iNrTrianglesIn; t++)
+	{
+		for(i=0; i<3; i++)
+		{
+			const int offs = t*3 + i;
+			const int index = piTriList_in_and_out[offs];
+
+			const SVec3 vP = GetPosition(pContext, index);
+			const SVec3 vN = GetNormal(pContext, index);
+			const SVec3 vT = GetTexCoord(pContext, index);
+
+			tbool bFound = TFALSE;
+			int t2=0, index2rec=-1;
+			while(!bFound && t2<=t)
+			{
+				int j=0;
+				while(!bFound && j<3)
+				{
+					const int index2 = piTriList_in_and_out[t2*3 + j];
+					const SVec3 vP2 = GetPosition(pContext, index2);
+					const SVec3 vN2 = GetNormal(pContext, index2);
+					const SVec3 vT2 = GetTexCoord(pContext, index2);
+
+					if(veq(vP,vP2) && veq(vN,vN2) && veq(vT,vT2))
+						bFound = TTRUE;
+					else
+						++j;
+				}
+				if(!bFound) ++t2;
+			}
+
+			assert(bFound);
+			// if we found our own
+			if(index2rec == index) { ++iNumUniqueVerts; }
+
+			piTriList_in_and_out[offs] = index2rec;
+		}
+	}
+}
+
+static int GenerateInitialVerticesIndexList(STriInfo pTriInfos[], int piTriList_out[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn)
+{
+	int iTSpacesOffs = 0, f=0, t=0;
+	int iDstTriIndex = 0;
+	for(f=0; f<pContext->m_pInterface->m_getNumFaces(pContext); f++)
+	{
+		const int verts = pContext->m_pInterface->m_getNumVerticesOfFace(pContext, f);
+		if(verts!=3 && verts!=4) continue;
+
+		pTriInfos[iDstTriIndex].iOrgFaceNumber = f;
+		pTriInfos[iDstTriIndex].iTSpacesOffs = iTSpacesOffs;
+
+		if(verts==3)
+		{
+			unsigned char * pVerts = pTriInfos[iDstTriIndex].vert_num;
+			pVerts[0]=0; pVerts[1]=1; pVerts[2]=2;
+			piTriList_out[iDstTriIndex*3+0] = MakeIndex(f, 0);
+			piTriList_out[iDstTriIndex*3+1] = MakeIndex(f, 1);
+			piTriList_out[iDstTriIndex*3+2] = MakeIndex(f, 2);
+			++iDstTriIndex;	// next
+		}
+		else
+		{
+			{
+				pTriInfos[iDstTriIndex+1].iOrgFaceNumber = f;
+				pTriInfos[iDstTriIndex+1].iTSpacesOffs = iTSpacesOffs;
+			}
+
+			{
+				// need an order independent way to evaluate
+				// tspace on quads. This is done by splitting
+				// along the shortest diagonal.
+				const int i0 = MakeIndex(f, 0);
+				const int i1 = MakeIndex(f, 1);
+				const int i2 = MakeIndex(f, 2);
+				const int i3 = MakeIndex(f, 3);
+				const SVec3 T0 = GetTexCoord(pContext, i0);
+				const SVec3 T1 = GetTexCoord(pContext, i1);
+				const SVec3 T2 = GetTexCoord(pContext, i2);
+				const SVec3 T3 = GetTexCoord(pContext, i3);
+				const float distSQ_02a = LengthSquared(vsub(T2,T0));
+				const float distSQ_13a = LengthSquared(vsub(T3,T1));
+				tbool bQuadDiagIs_02;
+				if(distSQ_02a < distSQ_13a)
+					bQuadDiagIs_02 = TTRUE;
+				else if(distSQ_13a < distSQ_02a)
+					bQuadDiagIs_02 = TFALSE;
+				else
+				{
+					const SVec3 P0 = GetPosition(pContext, i0);
+					const SVec3 P1 = GetPosition(pContext, i1);
+					const SVec3 P2 = GetPosition(pContext, i2);
+					const SVec3 P3 = GetPosition(pContext, i3);
+					const float distSQ_02b = LengthSquared(vsub(P2,P0));
+					const float distSQ_13b = LengthSquared(vsub(P3,P1));
+
+					bQuadDiagIs_02 = distSQ_13b < distSQ_02b ? TFALSE : TTRUE;
+				}
+
+				if(bQuadDiagIs_02)
+				{
+					{
+						unsigned char * pVerts_A = pTriInfos[iDstTriIndex].vert_num;
+						pVerts_A[0]=0; pVerts_A[1]=1; pVerts_A[2]=2;
+					}
+					piTriList_out[iDstTriIndex*3+0] = i0;
+					piTriList_out[iDstTriIndex*3+1] = i1;
+					piTriList_out[iDstTriIndex*3+2] = i2;
+					++iDstTriIndex;	// next
+					{
+						unsigned char * pVerts_B = pTriInfos[iDstTriIndex].vert_num;
+						pVerts_B[0]=0; pVerts_B[1]=2; pVerts_B[2]=3;
+					}
+					piTriList_out[iDstTriIndex*3+0] = i0;
+					piTriList_out[iDstTriIndex*3+1] = i2;
+					piTriList_out[iDstTriIndex*3+2] = i3;
+					++iDstTriIndex;	// next
+				}
+				else
+				{
+					{
+						unsigned char * pVerts_A = pTriInfos[iDstTriIndex].vert_num;
+						pVerts_A[0]=0; pVerts_A[1]=1; pVerts_A[2]=3;
+					}
+					piTriList_out[iDstTriIndex*3+0] = i0;
+					piTriList_out[iDstTriIndex*3+1] = i1;
+					piTriList_out[iDstTriIndex*3+2] = i3;
+					++iDstTriIndex;	// next
+					{
+						unsigned char * pVerts_B = pTriInfos[iDstTriIndex].vert_num;
+						pVerts_B[0]=1; pVerts_B[1]=2; pVerts_B[2]=3;
+					}
+					piTriList_out[iDstTriIndex*3+0] = i1;
+					piTriList_out[iDstTriIndex*3+1] = i2;
+					piTriList_out[iDstTriIndex*3+2] = i3;
+					++iDstTriIndex;	// next
+				}
+			}
+		}
+
+		iTSpacesOffs += verts;
+		assert(iDstTriIndex<=iNrTrianglesIn);
+	}
+
+	for(t=0; t<iNrTrianglesIn; t++)
+		pTriInfos[t].iFlag = 0;
+
+	// return total amount of tspaces
+	return iTSpacesOffs;
+}
+
+static SVec3 GetPosition(const SMikkTSpaceContext * pContext, const int index)
+{
+	int iF, iI;
+	SVec3 res; float pos[3];
+	IndexToData(&iF, &iI, index);
+	pContext->m_pInterface->m_getPosition(pContext, pos, iF, iI);
+	res.x=pos[0]; res.y=pos[1]; res.z=pos[2];
+	return res;
+}
+
+static SVec3 GetNormal(const SMikkTSpaceContext * pContext, const int index)
+{
+	int iF, iI;
+	SVec3 res; float norm[3];
+	IndexToData(&iF, &iI, index);
+	pContext->m_pInterface->m_getNormal(pContext, norm, iF, iI);
+	res.x=norm[0]; res.y=norm[1]; res.z=norm[2];
+	return res;
+}
+
+static SVec3 GetTexCoord(const SMikkTSpaceContext * pContext, const int index)
+{
+	int iF, iI;
+	SVec3 res; float texc[2];
+	IndexToData(&iF, &iI, index);
+	pContext->m_pInterface->m_getTexCoord(pContext, texc, iF, iI);
+	res.x=texc[0]; res.y=texc[1]; res.z=1.0f;
+	return res;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef union
+{
+	struct
+	{
+		int i0, i1, f;
+	};
+	int array[3];
+} SEdge;
+
+static void BuildNeighborsFast(STriInfo pTriInfos[], SEdge * pEdges, const int piTriListIn[], const int iNrTrianglesIn);
+static void BuildNeighborsSlow(STriInfo pTriInfos[], const int piTriListIn[], const int iNrTrianglesIn);
+
+// returns the texture area times 2
+static float CalcTexArea(const SMikkTSpaceContext * pContext, const int indices[])
+{
+	const SVec3 t1 = GetTexCoord(pContext, indices[0]);
+	const SVec3 t2 = GetTexCoord(pContext, indices[1]);
+	const SVec3 t3 = GetTexCoord(pContext, indices[2]);
+
+	const float t21x = t2.x-t1.x;
+	const float t21y = t2.y-t1.y;
+	const float t31x = t3.x-t1.x;
+	const float t31y = t3.y-t1.y;
+
+	const float fSignedAreaSTx2 = t21x*t31y - t21y*t31x;
+
+	return fSignedAreaSTx2<0 ? (-fSignedAreaSTx2) : fSignedAreaSTx2;
+}
+
+static void InitTriInfo(STriInfo pTriInfos[], const int piTriListIn[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn)
+{
+	int f=0, i=0, t=0;
+	// pTriInfos[f].iFlag is cleared in GenerateInitialVerticesIndexList() which is called before this function.
+
+	// generate neighbor info list
+	for(f=0; f<iNrTrianglesIn; f++)
+		for(i=0; i<3; i++)
+		{
+			pTriInfos[f].FaceNeighbors[i] = -1;
+			pTriInfos[f].AssignedGroup[i] = NULL;
+
+			pTriInfos[f].vOs.x=0.0f; pTriInfos[f].vOs.y=0.0f; pTriInfos[f].vOs.z=0.0f;
+			pTriInfos[f].vOt.x=0.0f; pTriInfos[f].vOt.y=0.0f; pTriInfos[f].vOt.z=0.0f;
+			pTriInfos[f].fMagS = 0;
+			pTriInfos[f].fMagT = 0;
+
+			// assumed bad
+			pTriInfos[f].iFlag |= GROUP_WITH_ANY;
+		}
+
+	// evaluate first order derivatives
+	for(f=0; f<iNrTrianglesIn; f++)
+	{
+		// initial values
+		const SVec3 v1 = GetPosition(pContext, piTriListIn[f*3+0]);
+		const SVec3 v2 = GetPosition(pContext, piTriListIn[f*3+1]);
+		const SVec3 v3 = GetPosition(pContext, piTriListIn[f*3+2]);
+		const SVec3 t1 = GetTexCoord(pContext, piTriListIn[f*3+0]);
+		const SVec3 t2 = GetTexCoord(pContext, piTriListIn[f*3+1]);
+		const SVec3 t3 = GetTexCoord(pContext, piTriListIn[f*3+2]);
+
+		const float t21x = t2.x-t1.x;
+		const float t21y = t2.y-t1.y;
+		const float t31x = t3.x-t1.x;
+		const float t31y = t3.y-t1.y;
+		const SVec3 d1 = vsub(v2,v1);
+		const SVec3 d2 = vsub(v3,v1);
+
+		const float fSignedAreaSTx2 = t21x*t31y - t21y*t31x;
+		//assert(fSignedAreaSTx2!=0);
+		SVec3 vOs = vsub(vscale(t31y,d1), vscale(t21y,d2));	// eq 18
+		SVec3 vOt = vadd(vscale(-t31x,d1), vscale(t21x,d2)); // eq 19
+
+		pTriInfos[f].iFlag |= (fSignedAreaSTx2>0 ? ORIENT_PRESERVING : 0);
+
+		if( NotZero(fSignedAreaSTx2) )
+		{
+			const float fAbsArea = fabsf(fSignedAreaSTx2);
+			const float fLenOs = Length(vOs);
+			const float fLenOt = Length(vOt);
+			const float fS = (pTriInfos[f].iFlag&ORIENT_PRESERVING)==0 ? (-1.0f) : 1.0f;
+			if( NotZero(fLenOs) ) pTriInfos[f].vOs = vscale(fS/fLenOs, vOs);
+			if( NotZero(fLenOt) ) pTriInfos[f].vOt = vscale(fS/fLenOt, vOt);
+
+			// evaluate magnitudes prior to normalization of vOs and vOt
+			pTriInfos[f].fMagS = fLenOs / fAbsArea;
+			pTriInfos[f].fMagT = fLenOt / fAbsArea;
+
+			// if this is a good triangle
+			if( NotZero(pTriInfos[f].fMagS) && NotZero(pTriInfos[f].fMagT))
+				pTriInfos[f].iFlag &= (~GROUP_WITH_ANY);
+		}
+	}
+
+	// force otherwise healthy quads to a fixed orientation
+	while(t<(iNrTrianglesIn-1))
+	{
+		const int iFO_a = pTriInfos[t].iOrgFaceNumber;
+		const int iFO_b = pTriInfos[t+1].iOrgFaceNumber;
+		if(iFO_a==iFO_b)	// this is a quad
+		{
+			const tbool bIsDeg_a = (pTriInfos[t].iFlag&MARK_DEGENERATE)!=0 ? TTRUE : TFALSE;
+			const tbool bIsDeg_b = (pTriInfos[t+1].iFlag&MARK_DEGENERATE)!=0 ? TTRUE : TFALSE;
+
+			// bad triangles should already have been removed by
+			// DegenPrologue(), but just in case check bIsDeg_a and bIsDeg_a are false
+			if((bIsDeg_a||bIsDeg_b)==TFALSE)
+			{
+				const tbool bOrientA = (pTriInfos[t].iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+				const tbool bOrientB = (pTriInfos[t+1].iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+				// if this happens the quad has extremely bad mapping!!
+				if(bOrientA!=bOrientB)
+				{
+					//printf("found quad with bad mapping\n");
+					tbool bChooseOrientFirstTri = TFALSE;
+					if((pTriInfos[t+1].iFlag&GROUP_WITH_ANY)!=0) bChooseOrientFirstTri = TTRUE;
+					else if( CalcTexArea(pContext, &piTriListIn[t*3+0]) >= CalcTexArea(pContext, &piTriListIn[(t+1)*3+0]) )
+						bChooseOrientFirstTri = TTRUE;
+
+					// force match
+					{
+						const int t0 = bChooseOrientFirstTri ? t : (t+1);
+						const int t1 = bChooseOrientFirstTri ? (t+1) : t;
+						pTriInfos[t1].iFlag &= (~ORIENT_PRESERVING);	// clear first
+						pTriInfos[t1].iFlag |= (pTriInfos[t0].iFlag&ORIENT_PRESERVING);	// copy bit
+					}
+				}
+			}
+			t += 2;
+		}
+		else
+			++t;
+	}
+
+	// match up edge pairs
+	{
+		SEdge * pEdges = (SEdge *) malloc(sizeof(SEdge)*iNrTrianglesIn*3);
+		if(pEdges==NULL)
+			BuildNeighborsSlow(pTriInfos, piTriListIn, iNrTrianglesIn);
+		else
+		{
+			BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn);
+
+			free(pEdges);
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static tbool AssignRecur(const int piTriListIn[], STriInfo psTriInfos[], const int iMyTriIndex, SGroup * pGroup);
+static void AddTriToGroup(SGroup * pGroup, const int iTriIndex);
+
+static int Build4RuleGroups(STriInfo pTriInfos[], SGroup pGroups[], int piGroupTrianglesBuffer[], const int piTriListIn[], const int iNrTrianglesIn)
+{
+	const int iNrMaxGroups = iNrTrianglesIn*3;
+	int iNrActiveGroups = 0;
+	int iOffset = 0, f=0, i=0;
+	for(f=0; f<iNrTrianglesIn; f++)
+	{
+		for(i=0; i<3; i++)
+		{
+			// if not assigned to a group
+			if((pTriInfos[f].iFlag&GROUP_WITH_ANY)==0 && pTriInfos[f].AssignedGroup[i]==NULL)
+			{
+				tbool bOrPre;
+				int neigh_indexL, neigh_indexR;
+				const int vert_index = piTriListIn[f*3+i];
+				assert(iNrActiveGroups<iNrMaxGroups);
+				pTriInfos[f].AssignedGroup[i] = &pGroups[iNrActiveGroups];
+				pTriInfos[f].AssignedGroup[i]->iVertexRepresentitive = vert_index;
+				pTriInfos[f].AssignedGroup[i]->bOrientPreservering = (pTriInfos[f].iFlag&ORIENT_PRESERVING)!=0;
+				pTriInfos[f].AssignedGroup[i]->iNrFaces = 0;
+				pTriInfos[f].AssignedGroup[i]->pFaceIndices = &piGroupTrianglesBuffer[iOffset];
+				++iNrActiveGroups;
+
+				AddTriToGroup(pTriInfos[f].AssignedGroup[i], f);
+				bOrPre = (pTriInfos[f].iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+				neigh_indexL = pTriInfos[f].FaceNeighbors[i];
+				neigh_indexR = pTriInfos[f].FaceNeighbors[i>0?(i-1):2];
+				if(neigh_indexL>=0) // neighbor
+				{
+					const tbool bAnswer =
+						AssignRecur(piTriListIn, pTriInfos, neigh_indexL,
+									pTriInfos[f].AssignedGroup[i] );
+
+					const tbool bOrPre2 = (pTriInfos[neigh_indexL].iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+					const tbool bDiff = bOrPre!=bOrPre2 ? TTRUE : TFALSE;
+					assert(bAnswer || bDiff);
+				}
+				if(neigh_indexR>=0) // neighbor
+				{
+					const tbool bAnswer =
+						AssignRecur(piTriListIn, pTriInfos, neigh_indexR,
+									pTriInfos[f].AssignedGroup[i] );
+
+					const tbool bOrPre2 = (pTriInfos[neigh_indexR].iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+					const tbool bDiff = bOrPre!=bOrPre2 ? TTRUE : TFALSE;
+					assert(bAnswer || bDiff);
+				}
+
+				// update offset
+				iOffset += pTriInfos[f].AssignedGroup[i]->iNrFaces;
+				// since the groups are disjoint a triangle can never
+				// belong to more than 3 groups. Subsequently something
+				// is completely screwed if this assertion ever hits.
+				assert(iOffset <= iNrMaxGroups);
+			}
+		}
+	}
+
+	return iNrActiveGroups;
+}
+
+static void AddTriToGroup(SGroup * pGroup, const int iTriIndex)
+{
+	pGroup->pFaceIndices[pGroup->iNrFaces] = iTriIndex;
+	++pGroup->iNrFaces;
+}
+
+static tbool AssignRecur(const int piTriListIn[], STriInfo psTriInfos[],
+				 const int iMyTriIndex, SGroup * pGroup)
+{
+	STriInfo * pMyTriInfo = &psTriInfos[iMyTriIndex];
+
+	// track down vertex
+	const int iVertRep = pGroup->iVertexRepresentitive;
+	const int * pVerts = &piTriListIn[3*iMyTriIndex+0];
+	int i=-1;
+	if(pVerts[0]==iVertRep) i=0;
+	else if(pVerts[1]==iVertRep) i=1;
+	else if(pVerts[2]==iVertRep) i=2;
+	assert(i>=0 && i<3);
+	PREFAST_ASSUME(i>=0 && i<3);
+
+	// early out
+	if(pMyTriInfo->AssignedGroup[i] == pGroup) return TTRUE;
+	else if(pMyTriInfo->AssignedGroup[i]!=NULL) return TFALSE;
+	if((pMyTriInfo->iFlag&GROUP_WITH_ANY)!=0)
+	{
+		// first to group with a group-with-anything triangle
+		// determines it's orientation.
+		// This is the only existing order dependency in the code!!
+		if( pMyTriInfo->AssignedGroup[0] == NULL &&
+			pMyTriInfo->AssignedGroup[1] == NULL &&
+			pMyTriInfo->AssignedGroup[2] == NULL )
+		{
+			pMyTriInfo->iFlag &= (~ORIENT_PRESERVING);
+			pMyTriInfo->iFlag |= (pGroup->bOrientPreservering ? ORIENT_PRESERVING : 0);
+		}
+	}
+	{
+		const tbool bOrient = (pMyTriInfo->iFlag&ORIENT_PRESERVING)!=0 ? TTRUE : TFALSE;
+		if(bOrient != pGroup->bOrientPreservering) return TFALSE;
+	}
+
+	AddTriToGroup(pGroup, iMyTriIndex);
+	pMyTriInfo->AssignedGroup[i] = pGroup;
+
+	{
+		const int neigh_indexL = pMyTriInfo->FaceNeighbors[i];
+		const int neigh_indexR = pMyTriInfo->FaceNeighbors[i>0?(i-1):2];
+		if(neigh_indexL>=0)
+			AssignRecur(piTriListIn, psTriInfos, neigh_indexL, pGroup);
+		if(neigh_indexR>=0)
+			AssignRecur(piTriListIn, psTriInfos, neigh_indexR, pGroup);
+	}
+
+
+
+	return TTRUE;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static tbool CompareSubGroups(const SSubGroup * pg1, const SSubGroup * pg2);
+static void QuickSort(int* pSortBuffer, int iLeft, int iRight, unsigned int uSeed);
+static STSpace EvalTspace(int face_indices[], const int iFaces, const int piTriListIn[], const STriInfo pTriInfos[], const SMikkTSpaceContext * pContext, const int iVertexRepresentitive);
+
+static tbool GenerateTSpaces(STSpace psTspace[], const STriInfo pTriInfos[], const SGroup pGroups[],
+					 const int iNrActiveGroups, const int piTriListIn[], const float fThresCos,
+					 const SMikkTSpaceContext * pContext)
+{
+	STSpace * pSubGroupTspace = NULL;
+	SSubGroup * pUniSubGroups = NULL;
+	int * pTmpMembers = NULL;
+	int iMaxNrFaces=0, iUniqueTspaces=0, g=0, i=0;
+	for(g=0; g<iNrActiveGroups; g++)
+		if(iMaxNrFaces < pGroups[g].iNrFaces)
+			iMaxNrFaces = pGroups[g].iNrFaces;
+
+	if(iMaxNrFaces == 0) return TTRUE;
+
+	// make initial allocations
+	pSubGroupTspace = (STSpace *) malloc(sizeof(STSpace)*iMaxNrFaces);
+	pUniSubGroups = (SSubGroup *) malloc(sizeof(SSubGroup)*iMaxNrFaces);
+	pTmpMembers = (int *) malloc(sizeof(int)*iMaxNrFaces);
+	if(pSubGroupTspace==NULL || pUniSubGroups==NULL || pTmpMembers==NULL)
+	{
+		if(pSubGroupTspace!=NULL) free(pSubGroupTspace);
+		if(pUniSubGroups!=NULL) free(pUniSubGroups);
+		if(pTmpMembers!=NULL) free(pTmpMembers);
+		return TFALSE;
+	}
+
+
+	iUniqueTspaces = 0;
+	for(g=0; g<iNrActiveGroups; g++)
+	{
+		const SGroup * pGroup = &pGroups[g];
+		int iUniqueSubGroups = 0;
+
+		for(i=0; i<pGroup->iNrFaces; i++)	// triangles
+		{
+			const int f = pGroup->pFaceIndices[i];	// triangle number
+			int index=-1, iVertIndex=-1, iOF_1=-1, iMembers=0, j=0, l=0;
+			SSubGroup tmp_group;
+			tbool bFound;
+			SVec3 n, vOs, vOt;
+			if(pTriInfos[f].AssignedGroup[0]==pGroup) index=0;
+			else if(pTriInfos[f].AssignedGroup[1]==pGroup) index=1;
+			else if(pTriInfos[f].AssignedGroup[2]==pGroup) index=2;
+			assert(index>=0 && index<3);
+
+			iVertIndex = piTriListIn[f*3+index];
+			assert(iVertIndex==pGroup->iVertexRepresentitive);
+
+			// is normalized already
+			n = GetNormal(pContext, iVertIndex);
+
+			// project
+			vOs = vsub(pTriInfos[f].vOs, vscale(vdot(n,pTriInfos[f].vOs), n));
+			vOt = vsub(pTriInfos[f].vOt, vscale(vdot(n,pTriInfos[f].vOt), n));
+			if( VNotZero(vOs) ) vOs = Normalize(vOs);
+			if( VNotZero(vOt) ) vOt = Normalize(vOt);
+
+			// original face number
+			iOF_1 = pTriInfos[f].iOrgFaceNumber;
+
+			iMembers = 0;
+			for(j=0; j<pGroup->iNrFaces; j++)
+			{
+				const int t = pGroup->pFaceIndices[j];	// triangle number
+				const int iOF_2 = pTriInfos[t].iOrgFaceNumber;
+
+				// project
+				SVec3 vOs2 = vsub(pTriInfos[t].vOs, vscale(vdot(n,pTriInfos[t].vOs), n));
+				SVec3 vOt2 = vsub(pTriInfos[t].vOt, vscale(vdot(n,pTriInfos[t].vOt), n));
+				if( VNotZero(vOs2) ) vOs2 = Normalize(vOs2);
+				if( VNotZero(vOt2) ) vOt2 = Normalize(vOt2);
+
+				{
+					const tbool bAny = ( (pTriInfos[f].iFlag | pTriInfos[t].iFlag) & GROUP_WITH_ANY )!=0 ? TTRUE : TFALSE;
+					// make sure triangles which belong to the same quad are joined.
+					const tbool bSameOrgFace = iOF_1==iOF_2 ? TTRUE : TFALSE;
+
+					const float fCosS = vdot(vOs,vOs2);
+					const float fCosT = vdot(vOt,vOt2);
+
+					assert(f!=t || bSameOrgFace);	// sanity check
+					if(bAny || bSameOrgFace || (fCosS>fThresCos && fCosT>fThresCos))
+						pTmpMembers[iMembers++] = t;
+				}
+			}
+
+			// sort pTmpMembers
+			tmp_group.iNrFaces = iMembers;
+			tmp_group.pTriMembers = pTmpMembers;
+			if(iMembers>1)
+			{
+				unsigned int uSeed = INTERNAL_RND_SORT_SEED;	// could replace with a random seed?
+				QuickSort(pTmpMembers, 0, iMembers-1, uSeed);
+			}
+
+			// look for an existing match
+			bFound = TFALSE;
+			l=0;
+			while(l<iUniqueSubGroups && !bFound)
+			{
+				bFound = CompareSubGroups(&tmp_group, &pUniSubGroups[l]);
+				if(!bFound) ++l;
+			}
+
+			// assign tangent space index
+			assert(bFound || l==iUniqueSubGroups);
+			//piTempTangIndices[f*3+index] = iUniqueTspaces+l;
+
+			// if no match was found we allocate a new subgroup
+			if(!bFound)
+			{
+				// insert new subgroup
+				int * pIndices = (int *) malloc(sizeof(int)*iMembers);
+				if(pIndices==NULL)
+				{
+					// clean up and return false
+					for(int s=0; s<iUniqueSubGroups; s++)
+						free(pUniSubGroups[s].pTriMembers);
+					free(pUniSubGroups);
+					free(pTmpMembers);
+					free(pSubGroupTspace);
+					return TFALSE;
+				}
+				pUniSubGroups[iUniqueSubGroups].iNrFaces = iMembers;
+				pUniSubGroups[iUniqueSubGroups].pTriMembers = pIndices;
+				memcpy(pIndices, tmp_group.pTriMembers, iMembers*sizeof(int));
+				pSubGroupTspace[iUniqueSubGroups] =
+					EvalTspace(tmp_group.pTriMembers, iMembers, piTriListIn, pTriInfos, pContext, pGroup->iVertexRepresentitive);
+				++iUniqueSubGroups;
+			}
+
+			// output tspace
+			{
+				PREFAST_ASSUME(f >= 0);
+				assert(f >= 0);
+				const int iOffs = pTriInfos[f].iTSpacesOffs;
+				assert(index >= 0);
+				PREFAST_ASSUME(index >= 0);
+				const int iVert = pTriInfos[f].vert_num[index];
+				assert(iOffs+iVert >= 0);
+				PREFAST_ASSUME(iOffs+iVert >= 0);
+				STSpace * pTS_out = &psTspace[iOffs+iVert];
+				assert(pTS_out->iCounter<2);
+				assert(((pTriInfos[f].iFlag&ORIENT_PRESERVING)!=0) == pGroup->bOrientPreservering);
+				if(pTS_out->iCounter==1)
+				{
+					*pTS_out = AvgTSpace(pTS_out, &pSubGroupTspace[l]);
+					pTS_out->iCounter = 2;	// update counter
+					pTS_out->bOrient = pGroup->bOrientPreservering;
+				}
+				else
+				{
+					assert(pTS_out->iCounter==0);
+					*pTS_out = pSubGroupTspace[l];
+					pTS_out->iCounter = 1;	// update counter
+					pTS_out->bOrient = pGroup->bOrientPreservering;
+				}
+			}
+		}
+
+		// clean up and offset iUniqueTspaces
+		for(int s=0; s<iUniqueSubGroups; s++)
+			free(pUniSubGroups[s].pTriMembers);
+		iUniqueTspaces += iUniqueSubGroups;
+		iUniqueSubGroups = 0;
+	}
+
+	// clean up
+	free(pUniSubGroups);
+	free(pTmpMembers);
+	free(pSubGroupTspace);
+
+	return TTRUE;
+}
+
+static STSpace EvalTspace(int face_indices[], const int iFaces, const int piTriListIn[], const STriInfo pTriInfos[],
+				   const SMikkTSpaceContext * pContext, const int iVertexRepresentitive)
+{
+	STSpace res;
+	float fAngleSum = 0;
+	int face=0;
+	res.vOs.x=0.0f; res.vOs.y=0.0f; res.vOs.z=0.0f;
+	res.vOt.x=0.0f; res.vOt.y=0.0f; res.vOt.z=0.0f;
+	res.fMagS = 0; res.fMagT = 0;
+
+	for(face=0; face<iFaces; face++)
+	{
+		const int f = face_indices[face];
+
+		// only valid triangles get to add their contribution
+		if( (pTriInfos[f].iFlag&GROUP_WITH_ANY)==0 )
+		{
+			SVec3 n, vOs, vOt, p0, p1, p2, v1, v2;
+			float fCos, fAngle, fMagS, fMagT;
+			int i=-1, index=-1, i0=-1, i1=-1, i2=-1;
+			if(piTriListIn[3*f+0]==iVertexRepresentitive) i=0;
+			else if(piTriListIn[3*f+1]==iVertexRepresentitive) i=1;
+			else if(piTriListIn[3*f+2]==iVertexRepresentitive) i=2;
+			assert(i>=0 && i<3);
+
+			// project
+			index = piTriListIn[3*f+i];
+			n = GetNormal(pContext, index);
+			vOs = vsub(pTriInfos[f].vOs, vscale(vdot(n,pTriInfos[f].vOs), n));
+			vOt = vsub(pTriInfos[f].vOt, vscale(vdot(n,pTriInfos[f].vOt), n));
+			if( VNotZero(vOs) ) vOs = Normalize(vOs);
+			if( VNotZero(vOt) ) vOt = Normalize(vOt);
+
+			i2 = piTriListIn[3*f + (i<2?(i+1):0)];
+			i1 = piTriListIn[3*f + i];
+			i0 = piTriListIn[3*f + (i>0?(i-1):2)];
+
+			p0 = GetPosition(pContext, i0);
+			p1 = GetPosition(pContext, i1);
+			p2 = GetPosition(pContext, i2);
+			v1 = vsub(p0,p1);
+			v2 = vsub(p2,p1);
+
+			// project
+			v1 = vsub(v1, vscale(vdot(n,v1),n)); if( VNotZero(v1) ) v1 = Normalize(v1);
+			v2 = vsub(v2, vscale(vdot(n,v2),n)); if( VNotZero(v2) ) v2 = Normalize(v2);
+
+			// weight contribution by the angle
+			// between the two edge vectors
+			fCos = vdot(v1,v2); fCos=fCos>1?1:(fCos<(-1) ? (-1) : fCos);
+			fAngle = (const float) acos(fCos);
+			fMagS = pTriInfos[f].fMagS;
+			fMagT = pTriInfos[f].fMagT;
+
+			res.vOs=vadd(res.vOs, vscale(fAngle,vOs));
+			res.vOt=vadd(res.vOt,vscale(fAngle,vOt));
+			res.fMagS+=(fAngle*fMagS);
+			res.fMagT+=(fAngle*fMagT);
+			fAngleSum += fAngle;
+		}
+	}
+
+	// normalize
+	if( VNotZero(res.vOs) ) res.vOs = Normalize(res.vOs);
+	if( VNotZero(res.vOt) ) res.vOt = Normalize(res.vOt);
+	if(fAngleSum>0)
+	{
+		res.fMagS /= fAngleSum;
+		res.fMagT /= fAngleSum;
+	}
+
+	return res;
+}
+
+static tbool CompareSubGroups(const SSubGroup * pg1, const SSubGroup * pg2)
+{
+	tbool bStillSame=TTRUE;
+	int i=0;
+	if(pg1->iNrFaces!=pg2->iNrFaces) return TFALSE;
+	while(i<pg1->iNrFaces && bStillSame)
+	{
+		bStillSame = pg1->pTriMembers[i]==pg2->pTriMembers[i] ? TTRUE : TFALSE;
+		if(bStillSame) ++i;
+	}
+	return bStillSame;
+}
+
+static void QuickSort(int* pSortBuffer, int iLeft, int iRight, unsigned int uSeed)
+{
+	int iL, iR, n, index, iMid, iTmp;
+
+	// Random
+	unsigned int t=uSeed&31;
+	t=(uSeed<<t)|(uSeed>>(32-t));
+	uSeed=uSeed+t+3;
+	// Random end
+
+	iL=iLeft; iR=iRight;
+	n = (iR-iL)+1;
+	assert(n>=0);
+	index = (int) (uSeed%n);
+
+	iMid=pSortBuffer[index + iL];
+
+
+	do
+	{
+		while(pSortBuffer[iL] < iMid)
+			++iL;
+		while(pSortBuffer[iR] > iMid)
+			--iR;
+
+		if(iL <= iR)
+		{
+			iTmp = pSortBuffer[iL];
+			pSortBuffer[iL] = pSortBuffer[iR];
+			pSortBuffer[iR] = iTmp;
+			++iL; --iR;
+		}
+	}
+	while(iL <= iR);
+
+	if(iLeft < iR)
+		QuickSort(pSortBuffer, iLeft, iR, uSeed);
+	if(iL < iRight)
+		QuickSort(pSortBuffer, iL, iRight, uSeed);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+static void QuickSortEdges(SEdge * pSortBuffer, int iLeft, int iRight, const int channel, unsigned int uSeed);
+static void GetEdge(int * i0_out, int * i1_out, int * edgenum_out, const int indices[], const int i0_in, const int i1_in);
+
+static void BuildNeighborsFast(STriInfo pTriInfos[], SEdge * pEdges, const int piTriListIn[], const int iNrTrianglesIn)
+{
+	// build array of edges
+	unsigned int uSeed = INTERNAL_RND_SORT_SEED;				// could replace with a random seed?
+	int iEntries=0, iCurStartIndex=-1, i=0;
+	for(int f=0; f<iNrTrianglesIn; f++)
+		for(i=0; i<3; i++)
+		{
+			const int i0 = piTriListIn[f*3+i];
+			const int i1 = piTriListIn[f*3+(i<2?(i+1):0)];
+			pEdges[f*3+i].i0 = i0 < i1 ? i0 : i1;			// put minimum index in i0
+			pEdges[f*3+i].i1 = !(i0 < i1) ? i0 : i1;		// put maximum index in i1
+			pEdges[f*3+i].f = f;							// record face number
+		}
+
+	// sort over all edges by i0, this is the pricy one.
+	QuickSortEdges(pEdges, 0, iNrTrianglesIn*3-1, 0, uSeed);	// sort channel 0 which is i0
+
+	// sub sort over i1, should be fast.
+	// could replace this with a 64 bit int sort over (i0,i1)
+	// with i0 as msb in the quicksort call above.
+	iEntries = iNrTrianglesIn*3;
+	iCurStartIndex = 0;
+	for(i=1; i<iEntries; i++)
+	{
+		if(pEdges[iCurStartIndex].i0 != pEdges[i].i0)
+		{
+			const int iL = iCurStartIndex;
+			const int iR = i-1;
+			//const int iElems = i-iL;
+			iCurStartIndex = i;
+			QuickSortEdges(pEdges, iL, iR, 1, uSeed);	// sort channel 1 which is i1
+		}
+	}
+
+	// sub sort over f, which should be fast.
+	// this step is to remain compliant with BuildNeighborsSlow() when
+	// more than 2 triangles use the same edge (such as a butterfly topology).
+	iCurStartIndex = 0;
+	for(i=1; i<iEntries; i++)
+	{
+		if(pEdges[iCurStartIndex].i0 != pEdges[i].i0 || pEdges[iCurStartIndex].i1 != pEdges[i].i1)
+		{
+			const int iL = iCurStartIndex;
+			const int iR = i-1;
+			//const int iElems = i-iL;
+			iCurStartIndex = i;
+			QuickSortEdges(pEdges, iL, iR, 2, uSeed);	// sort channel 2 which is f
+		}
+	}
+
+	// pair up, adjacent triangles
+	for(i=0; i<iEntries; i++)
+	{
+		const int i0=pEdges[i].i0;
+		const int i1=pEdges[i].i1;
+		const int f = pEdges[i].f;
+		tbool bUnassigned_A;
+
+		int i0_A, i1_A;
+		int edgenum_A, edgenum_B=0;	// 0,1 or 2
+		GetEdge(&i0_A, &i1_A, &edgenum_A, &piTriListIn[f*3], i0, i1);	// resolve index ordering and edge_num
+		bUnassigned_A = pTriInfos[f].FaceNeighbors[edgenum_A] == -1 ? TTRUE : TFALSE;
+
+		if(bUnassigned_A)
+		{
+			// get true index ordering
+			int j=i+1;
+			tbool bNotFound = TTRUE;
+			while(j<iEntries && i0==pEdges[j].i0 && i1==pEdges[j].i1 && bNotFound)
+			{
+				tbool bUnassigned_B;
+				int i0_B, i1_B;
+				int t = pEdges[j].f;
+				// flip i0_B and i1_B
+				GetEdge(&i1_B, &i0_B, &edgenum_B, &piTriListIn[t*3], pEdges[j].i0, pEdges[j].i1);	// resolve index ordering and edge_num
+				//assert(!(i0_A==i1_B && i1_A==i0_B));
+				bUnassigned_B =  pTriInfos[t].FaceNeighbors[edgenum_B]==-1 ? TTRUE : TFALSE;
+				if(i0_A==i0_B && i1_A==i1_B && bUnassigned_B)
+					bNotFound = TFALSE;
+				else
+					++j;
+			}
+
+			if(!bNotFound)
+			{
+				int t = pEdges[j].f;
+				pTriInfos[f].FaceNeighbors[edgenum_A] = t;
+				//assert(pTriInfos[t].FaceNeighbors[edgenum_B]==-1);
+				pTriInfos[t].FaceNeighbors[edgenum_B] = f;
+			}
+		}
+	}
+}
+
+static void BuildNeighborsSlow(STriInfo pTriInfos[], const int piTriListIn[], const int iNrTrianglesIn)
+{
+	int f=0, i=0;
+	for(f=0; f<iNrTrianglesIn; f++)
+	{
+		for(i=0; i<3; i++)
+		{
+			// if unassigned
+			if(pTriInfos[f].FaceNeighbors[i] == -1)
+			{
+				const int i0_A = piTriListIn[f*3+i];
+				const int i1_A = piTriListIn[f*3+(i<2?(i+1):0)];
+
+				// search for a neighbor
+				tbool bFound = TFALSE;
+				int t=0, j=0;
+				while(!bFound && t<iNrTrianglesIn)
+				{
+					if(t!=f)
+					{
+						j=0;
+						while(!bFound && j<3)
+						{
+							// in rev order
+							const int i1_B = piTriListIn[t*3+j];
+							const int i0_B = piTriListIn[t*3+(j<2?(j+1):0)];
+							//assert(!(i0_A==i1_B && i1_A==i0_B));
+							if(i0_A==i0_B && i1_A==i1_B)
+								bFound = TTRUE;
+							else
+								++j;
+						}
+					}
+
+					if(!bFound) ++t;
+				}
+
+				// assign neighbors
+				if(bFound)
+				{
+					pTriInfos[f].FaceNeighbors[i] = t;
+					//assert(pTriInfos[t].FaceNeighbors[j]==-1);
+					pTriInfos[t].FaceNeighbors[j] = f;
+				}
+			}
+		}
+	}
+}
+
+static void QuickSortEdges(SEdge * pSortBuffer, int iLeft, int iRight, const int channel, unsigned int uSeed)
+{
+	unsigned int t;
+	int iL, iR, n, index, iMid;
+
+	// early out
+	SEdge sTmp;
+	const int iElems = iRight-iLeft+1;
+	if(iElems<2) return;
+	else if(iElems==2)
+	{
+		if(pSortBuffer[iLeft].array[channel] > pSortBuffer[iRight].array[channel])
+		{
+			sTmp = pSortBuffer[iLeft];
+			pSortBuffer[iLeft] = pSortBuffer[iRight];
+			pSortBuffer[iRight] = sTmp;
+		}
+		return;
+	}
+
+	// Random
+	t=uSeed&31;
+	t=(uSeed<<t)|(uSeed>>(32-t));
+	uSeed=uSeed+t+3;
+	// Random end
+
+	iL=iLeft, iR=iRight;
+	n = (iR-iL)+1;
+	assert(n>=0);
+	index = (int) (uSeed%n);
+
+	iMid=pSortBuffer[index + iL].array[channel];
+
+	do
+	{
+		while(pSortBuffer[iL].array[channel] < iMid)
+			++iL;
+		while(pSortBuffer[iR].array[channel] > iMid)
+			--iR;
+
+		if(iL <= iR)
+		{
+			sTmp = pSortBuffer[iL];
+			pSortBuffer[iL] = pSortBuffer[iR];
+			pSortBuffer[iR] = sTmp;
+			++iL; --iR;
+		}
+	}
+	while(iL <= iR);
+
+	if(iLeft < iR)
+		QuickSortEdges(pSortBuffer, iLeft, iR, channel, uSeed);
+	if(iL < iRight)
+		QuickSortEdges(pSortBuffer, iL, iRight, channel, uSeed);
+}
+
+// resolve ordering and edge number
+static void GetEdge(int * i0_out, int * i1_out, int * edgenum_out, const int indices[], const int i0_in, const int i1_in)
+{
+	*edgenum_out = -1;
+
+	// test if first index is on the edge
+	if(indices[0]==i0_in || indices[0]==i1_in)
+	{
+		// test if second index is on the edge
+		if(indices[1]==i0_in || indices[1]==i1_in)
+		{
+			edgenum_out[0]=0;	// first edge
+			i0_out[0]=indices[0];
+			i1_out[0]=indices[1];
+		}
+		else
+		{
+			edgenum_out[0]=2;	// third edge
+			i0_out[0]=indices[2];
+			i1_out[0]=indices[0];
+		}
+	}
+	else
+	{
+		// only second and third index is on the edge
+		edgenum_out[0]=1;	// second edge
+		i0_out[0]=indices[1];
+		i1_out[0]=indices[2];
+	}
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////// Degenerate triangles ////////////////////////////////////
+
+static void DegenPrologue(STriInfo pTriInfos[], int piTriList_out[], const int iNrTrianglesIn, const int iTotTris)
+{
+	int iNextGoodTriangleSearchIndex=-1;
+	tbool bStillFindingGoodOnes;
+
+	// locate quads with only one good triangle
+	int t=0;
+	while(t<(iTotTris-1))
+	{
+		const int iFO_a = pTriInfos[t].iOrgFaceNumber;
+		const int iFO_b = pTriInfos[t+1].iOrgFaceNumber;
+		if(iFO_a==iFO_b)	// this is a quad
+		{
+			const tbool bIsDeg_a = (pTriInfos[t].iFlag&MARK_DEGENERATE)!=0 ? TTRUE : TFALSE;
+			const tbool bIsDeg_b = (pTriInfos[t+1].iFlag&MARK_DEGENERATE)!=0 ? TTRUE : TFALSE;
+			if((bIsDeg_a^bIsDeg_b)!=0)
+			{
+				pTriInfos[t].iFlag |= QUAD_ONE_DEGEN_TRI;
+				pTriInfos[t+1].iFlag |= QUAD_ONE_DEGEN_TRI;
+			}
+			t += 2;
+		}
+		else
+			++t;
+	}
+
+	// reorder list so all degen triangles are moved to the back
+	// without reordering the good triangles
+	iNextGoodTriangleSearchIndex = 1;
+	t=0;
+	bStillFindingGoodOnes = TTRUE;
+	while(t<iNrTrianglesIn && bStillFindingGoodOnes)
+	{
+		const tbool bFirstIsGood = (pTriInfos[t].iFlag&MARK_DEGENERATE)==0 ? TTRUE : TFALSE;
+		if(bFirstIsGood)
+		{
+			if(iNextGoodTriangleSearchIndex < (t+2))
+				iNextGoodTriangleSearchIndex = t+2;
+		}
+		else
+		{
+			int t0, t1;
+			// search for the first good triangle.
+			tbool bJustADegenerate = TTRUE;
+			while(bJustADegenerate && iNextGoodTriangleSearchIndex<iTotTris)
+			{
+				const tbool bIsGood = (pTriInfos[iNextGoodTriangleSearchIndex].iFlag&MARK_DEGENERATE)==0 ? TTRUE : TFALSE;
+				if(bIsGood) bJustADegenerate=TFALSE;
+				else ++iNextGoodTriangleSearchIndex;
+			}
+
+			t0 = t;
+			t1 = iNextGoodTriangleSearchIndex;
+			++iNextGoodTriangleSearchIndex;
+			assert(iNextGoodTriangleSearchIndex > (t+1));
+
+			// swap triangle t0 and t1
+			if(!bJustADegenerate)
+			{
+				int i=0;
+				for(i=0; i<3; i++)
+				{
+					const int index = piTriList_out[t0*3+i];
+					piTriList_out[t0*3+i] = piTriList_out[t1*3+i];
+					piTriList_out[t1*3+i] = index;
+				}
+				{
+					const STriInfo tri_info = pTriInfos[t0];
+					pTriInfos[t0] = pTriInfos[t1];
+					pTriInfos[t1] = tri_info;
+				}
+			}
+			else
+				bStillFindingGoodOnes = TFALSE;	// this is not supposed to happen
+		}
+
+		if(bStillFindingGoodOnes) ++t;
+	}
+
+	assert(bStillFindingGoodOnes);	// code will still work.
+	assert(iNrTrianglesIn == t);
+}
+
+namespace
+{
+struct IndexLess
+{
+	const int* const m_pIndices;
+
+	IndexLess(const int* const pIndices)
+		: m_pIndices(pIndices)
+	{
+	}
+
+	bool operator()(int a, int b) const
+	{
+		return m_pIndices[a]<m_pIndices[b];
+	}
+};
+}
+
+static tbool DegenEpilogue(STSpace psTspace[], STriInfo pTriInfos[], int piTriListIn[], const SMikkTSpaceContext * pContext, const int iNrTrianglesIn, const int iTotTris)
+{
+	// deal with degenerate triangles
+	// punishment for degenerate triangles is O(N log N)
+	if (iTotTris > iNrTrianglesIn)
+	{
+		const IndexLess less(piTriListIn);
+
+		assert(iNrTrianglesIn > 0);
+		const int iNrIndicesIn = iNrTrianglesIn*3;
+
+		int* const piSort = (int *)malloc(sizeof(int)*iNrIndicesIn);
+		if(piSort==NULL)
+			return TFALSE;
+
+		for (int i=0; i<iNrIndicesIn; i++)
+			piSort[i] = i;
+
+		std::stable_sort(&piSort[0], &piSort[iNrIndicesIn], less);
+
+		for(int t=iNrTrianglesIn; t<iTotTris; t++)
+		{
+			// degenerate triangles on a quad with one good triangle are skipped
+			// here but processed in the next loop
+			const tbool bSkip = (pTriInfos[t].iFlag&QUAD_ONE_DEGEN_TRI)!=0 ? TTRUE : TFALSE;
+
+			if(!bSkip)
+			{
+				for(int i=0; i<3; i++)
+				{
+					const int index = piTriListIn[t*3+i];
+
+					// search through the good triangles
+					// we use custom code to search for 'index' because
+					// using std::lower_bound with index arrays is a bit tricky
+					int imin = 0;
+					int count = iNrIndicesIn;
+					while(count>0)
+					{
+						const int step=count>>1;
+						if(piTriListIn[piSort[imin+step]]<index)
+						{
+							imin += step+1;
+							count -= step+1;
+						}
+						else
+							count = step;
+					}
+
+					if (imin<iNrIndicesIn && piTriListIn[piSort[imin]]==index)
+					{
+						const int j = piSort[imin];
+						const int iTri = j/3;
+						const int iVert = j%3;
+						const int iSrcVert=pTriInfos[iTri].vert_num[iVert];
+						const int iSrcOffs=pTriInfos[iTri].iTSpacesOffs;
+						const int iDstVert=pTriInfos[t].vert_num[i];
+						const int iDstOffs=pTriInfos[t].iTSpacesOffs;
+
+						// copy tspace
+						psTspace[iDstOffs+iDstVert] = psTspace[iSrcOffs+iSrcVert];
+					}
+				}
+			}
+		}
+
+		free(piSort);
+	}
+
+	// deal with degenerate quads with one good triangle
+	for(int t=0; t<iNrTrianglesIn; t++)
+	{
+		// this triangle belongs to a quad where the
+		// other triangle is degenerate
+		if( (pTriInfos[t].iFlag&QUAD_ONE_DEGEN_TRI)!=0 )
+		{
+			SVec3 vDstP;
+			int iOrgF=-1, i=0;
+			tbool bNotFound;
+			unsigned char * pV = pTriInfos[t].vert_num;
+			int iFlag = (1<<pV[0]) | (1<<pV[1]) | (1<<pV[2]);
+			int iMissingIndex = 0;
+			if((iFlag&2)==0) iMissingIndex=1;
+			else if((iFlag&4)==0) iMissingIndex=2;
+			else if((iFlag&8)==0) iMissingIndex=3;
+
+			iOrgF = pTriInfos[t].iOrgFaceNumber;
+			vDstP = GetPosition(pContext, MakeIndex(iOrgF, iMissingIndex));
+			bNotFound = TTRUE;
+			i=0;
+			while(bNotFound && i<3)
+			{
+				const int iVert = pV[i];
+				const SVec3 vSrcP = GetPosition(pContext, MakeIndex(iOrgF, iVert));
+				if(veq(vSrcP, vDstP)==TTRUE)
+				{
+					const int iOffs = pTriInfos[t].iTSpacesOffs;
+					psTspace[iOffs+iMissingIndex] = psTspace[iOffs+iVert];
+					bNotFound=TFALSE;
+				}
+				else
+					++i;
+			}
+			assert(!bNotFound);
+		}
+	}
+
+	return TTRUE;
+}

+ 143 - 0
package-system/mikkelsen/mikktspace.h

@@ -0,0 +1,143 @@
+/**
+ *  Copyright (C) 2011 by Morten S. Mikkelsen
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty.  In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ *  2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ *  3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef __MIKKTSPACE_H__
+#define __MIKKTSPACE_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Author: Morten S. Mikkelsen
+ * Version: 1.0
+ *
+ * The files mikktspace.h and mikktspace.c are designed to be
+ * stand-alone files and it is important that they are kept this way.
+ * Not having dependencies on structures/classes/libraries specific
+ * to the program, in which they are used, allows them to be copied
+ * and used as is into any tool, program or plugin.
+ * The code is designed to consistently generate the same
+ * tangent spaces, for a given mesh, in any tool in which it is used.
+ * This is done by performing an internal welding step and subsequently an order-independent evaluation
+ * of tangent space for meshes consisting of triangles and quads.
+ * This means faces can be received in any order and the same is true for
+ * the order of vertices of each face. The generated result will not be affected
+ * by such reordering. Additionally, whether degenerate (vertices or texture coordinates)
+ * primitives are present or not will not affect the generated results either.
+ * Once tangent space calculation is done the vertices of degenerate primitives will simply
+ * inherit tangent space from neighboring non degenerate primitives.
+ * The analysis behind this implementation can be found in my master's thesis
+ * which is available for download --> http://image.diku.dk/projects/media/morten.mikkelsen.08.pdf
+ * Note that though the tangent spaces at the vertices are generated in an order-independent way,
+ * by this implementation, the interpolated tangent space is still affected by which diagonal is
+ * chosen to split each quad. A sensible solution is to have your tools pipeline always
+ * split quads by the shortest diagonal. This choice is order-independent and works with mirroring.
+ * If these have the same length then compare the diagonals defined by the texture coordinates.
+ * XNormal which is a tool for baking normal maps allows you to write your own tangent space plugin
+ * and also quad triangulator plugin.
+ */
+
+
+typedef int tbool;
+typedef struct SMikkTSpaceContext SMikkTSpaceContext;
+
+typedef struct
+{
+	// Returns the number of faces (triangles/quads) on the mesh to be processed.
+	int (*m_getNumFaces)(const SMikkTSpaceContext * pContext);
+
+	// Returns the number of vertices on face number iFace
+	// iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+	int (*m_getNumVerticesOfFace)(const SMikkTSpaceContext * pContext, const int iFace);
+
+	// returns the position/normal/texcoord of the referenced face of vertex number iVert.
+	// iVert is in the range {0,1,2} for triangles and {0,1,2,3} for quads.
+	void (*m_getPosition)(const SMikkTSpaceContext * pContext, float fvPosOut[], const int iFace, const int iVert);
+	void (*m_getNormal)(const SMikkTSpaceContext * pContext, float fvNormOut[], const int iFace, const int iVert);
+	void (*m_getTexCoord)(const SMikkTSpaceContext * pContext, float fvTexcOut[], const int iFace, const int iVert);
+
+	// either (or both) of the two setTSpace callbacks can be set.
+	// The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+
+	// This function is used to return the tangent and fSign to the application.
+	// fvTangent is a unit length vector.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpaceBasic)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int iFace, const int iVert);
+
+	// This function is used to return tangent space results to the application.
+	// fvTangent and fvBiTangent are unit length vectors and fMagS and fMagT are their
+	// true magnitudes which can be used for relief mapping effects.
+	// fvBiTangent is the "real" bitangent and thus may not be perpendicular to fvTangent.
+	// However, both are perpendicular to the vertex normal.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// fSign = bIsOrientationPreserving ? 1.0f : (-1.0f);
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpace)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
+						const tbool bIsOrientationPreserving, const int iFace, const int iVert);
+} SMikkTSpaceInterface;
+
+struct SMikkTSpaceContext
+{
+	SMikkTSpaceInterface * m_pInterface;	// initialized with callback functions
+	void * m_pUserData;						// pointer to client side mesh data etc. (passed as the first parameter with every interface call)
+};
+
+// these are both thread safe!
+tbool genTangSpaceDefault(const SMikkTSpaceContext * pContext);	// Default (recommended) fAngularThreshold is 180 degrees (which means threshold disabled)
+tbool genTangSpace(const SMikkTSpaceContext * pContext, const float fAngularThreshold);
+
+
+// To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
+// normal map sampler must use the exact inverse of the pixel shader transformation.
+// The most efficient transformation we can possibly do in the pixel shader is
+// achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
+// pixel shader (fast transform out)
+// vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+// where vNt is the tangent space normal. The normal map sampler must likewise use the
+// interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
+// sampler does (exact inverse of pixel shader):
+// float3 row0 = cross(vB, vN);
+// float3 row1 = cross(vN, vT);
+// float3 row2 = cross(vT, vB);
+// float fSign = dot(vT, row0)<0 ? -1 : 1;
+// vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
+// where vNout is the sampled normal in some chosen 3D space.
+//
+// Should you choose to reconstruct the bitangent in the pixel shader instead
+// of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
+// Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
+// quads as your renderer then problems will occur since the interpolated tangent spaces will differ
+// eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
+// sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
+// However, this must be used both by the sampler and your tools/rendering pipeline.
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

+ 42 - 0
package-system/poly2tri/Findpoly2tri.cmake

@@ -0,0 +1,42 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(LIB_NAME "poly2tri")
+
+set(TARGET_WITH_NAMESPACE "3rdParty::${LIB_NAME}")
+if (TARGET ${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(${LIB_NAME}_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/${LIB_NAME}/${LIB_NAME}/include/${LIB_NAME})
+set(${LIB_NAME}_LIBS_DIR ${CMAKE_CURRENT_LIST_DIR}/${LIB_NAME}/${LIB_NAME}/lib)
+
+if (${PAL_PLATFORM_NAME} STREQUAL "Windows")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/poly2tri.lib)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/poly2tri.lib)
+elseif (${PAL_PLATFORM_NAME} STREQUAL "Mac")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/libpoly2tri.a)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/libpoly2tri.a)
+elseif (${PAL_PLATFORM_NAME} STREQUAL "Linux")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/libpoly2tri.a)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/libpoly2tri.a)
+endif()
+
+set(${LIB_NAME}_LIBRARY
+    "$<$<CONFIG:profile>:${${LIB_NAME}_LIBRARY_RELEASE}>"
+    "$<$<CONFIG:release>:${${LIB_NAME}_LIBRARY_RELEASE}>"
+    "$<$<CONFIG:debug>:${${LIB_NAME}_LIBRARY_DEBUG}>")
+
+add_library(${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(
+    TARGET ${TARGET_WITH_NAMESPACE} INTERFACE ${${LIB_NAME}_INCLUDE_DIR})
+target_link_libraries(
+    ${TARGET_WITH_NAMESPACE}
+    INTERFACE ${${LIB_NAME}_LIBRARY})
+
+set(${LIB_NAME}_FOUND True)

+ 29 - 0
package-system/poly2tri/build-poly2tri-jhasse-repo.patch

@@ -0,0 +1,29 @@
+diff --git a/ports/poly2tri/CONTROL b/ports/poly2tri/CONTROL
+index 21ed149e3..b295a1fb7 100644
+--- a/ports/poly2tri/CONTROL
++++ b/ports/poly2tri/CONTROL
+@@ -1,5 +1,5 @@
+ Source: poly2tri
+-Version: 2020-07-21
+-Homepage: https://github.com/greenm01/poly2tri
++Version: 2021-05-18
++Homepage: https://github.com/jhasse/poly2tri
+ Description: The Clipper library performs clipping and offsetting for both lines and polygons. All four boolean clipping operations are supported - intersection, union, difference and exclusive-or. Polygons can be of any shape including self-intersecting polygons.
+ Supports: !uwp
+diff --git a/ports/poly2tri/portfile.cmake b/ports/poly2tri/portfile.cmake
+index 278e3d8ee..01210ecee 100644
+--- a/ports/poly2tri/portfile.cmake
++++ b/ports/poly2tri/portfile.cmake
+@@ -4,9 +4,9 @@ vcpkg_check_linkage(ONLY_STATIC_LIBRARY)
+ 
+ vcpkg_from_github(
+     OUT_SOURCE_PATH SOURCE_PATH
+-    REPO greenm01/poly2tri
+-    REF 88de49021b6d9bef6faa1bc94ceb3fbd85c3c204
+-    SHA512 fa256bcf923ad59f42205edf5a7e07cac6cbd9a37cefb9a0961a2e06aea7fa8ffd09d4e26154c0028601c12804483842cb935d9f602385f5f203c9628382c4fb
++    REPO jhasse/poly2tri
++    REF 7f0487a81124647f0a4037c4706ff414ce9fe22b
++    SHA512 1666bca16cef75bd68c8be257f2f1c50155847ab046b3c756da9ea883bbf3139d6292b833f1d6113186accc4bba860270bb261f537744aece35bfee6a611cf5f
+     HEAD_REF master
+ )
+ 

+ 85 - 0
package-system/poly2tri/build_package_image.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import argparse
+import shutil
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent / 'Scripts'))
+from builders.vcpkgbuilder import VcpkgBuilder
+import builders.monkeypatch_tempdir_cleanup
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--platform-name',
+        dest='platformName',
+        choices=['windows', 'mac', 'linux'],
+        default=VcpkgBuilder.defaultPackagePlatformName(),
+    )
+    args = parser.parse_args()
+
+    packageSystemDir = Path(__file__).resolve().parents[1]
+    packageSourceDir = packageSystemDir / 'poly2tri'
+    outputDir = packageSystemDir / f'poly2tri-{args.platformName}'
+
+    cmakeFindFile = packageSourceDir / f'Findpoly2tri_{args.platformName}.cmake'
+    if not cmakeFindFile.exists():
+        cmakeFindFile = packageSourceDir / 'Findpoly2tri.cmake'
+
+    # vcpkg uses https://github.com/greenm01/poly2tri repo (88de490), but we need
+    # the more recent version from https://github.com/jhasse/poly2tri repo (7f0487a),
+    # patching vcpkg to build jhasse version.
+    buildJhasseRepoPatch = (packageSourceDir / 'build-poly2tri-jhasse-repo.patch')
+        
+    with TemporaryDirectory() as tempdir:
+        tempdir = Path(tempdir)
+        
+        builder = VcpkgBuilder(
+            packageName='poly2tri',
+            portName='poly2tri',
+            vcpkgDir=tempdir,
+            targetPlatform=args.platformName,
+            static=True
+        )
+        
+        builder.cloneVcpkg('751fc199af8d33eb300af5edbd9e3b77c48f0bca')
+        builder.patch(buildJhasseRepoPatch)
+        builder.bootstrap()
+        builder.build()
+        
+        builder.copyBuildOutputTo(
+            outputDir,
+            extraFiles={
+                next(builder.vcpkgDir.glob(f'buildtrees/poly2tri/src/*/LICENSE')): outputDir / builder.packageName / 'LICENSE',
+                next(builder.vcpkgDir.glob(f'buildtrees/poly2tri/src/*/README.md')): outputDir / builder.packageName / 'README.md',
+            },
+            subdir='poly2tri'
+        )
+        
+        # vcpkg's commit 751fc19 uses poly2tri's commit 7f0487a (after patch)
+        builder.writePackageInfoFile(
+            outputDir,
+            settings={
+                'PackageName': f'poly2tri-7f0487a-rev1-{args.platformName}',
+                'URL': 'https://github.com/jhasse/poly2tri',
+                'License': 'BSD-3-Clause',
+                'LicenseFile': 'poly2tri/LICENSE'
+            },
+        )
+        
+        shutil.copy2(
+            src=cmakeFindFile,
+            dst=outputDir / 'Findpoly2tri.cmake'
+        )
+
+if __name__ == '__main__':
+    main()

+ 42 - 0
package-system/v-hacd/Findv-hacd.cmake

@@ -0,0 +1,42 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(LIB_NAME "v-hacd")
+
+set(TARGET_WITH_NAMESPACE "3rdParty::${LIB_NAME}")
+if (TARGET ${TARGET_WITH_NAMESPACE})
+    return()
+endif()
+
+set(${LIB_NAME}_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/${LIB_NAME}/${LIB_NAME}/include)
+set(${LIB_NAME}_LIBS_DIR ${CMAKE_CURRENT_LIST_DIR}/${LIB_NAME}/${LIB_NAME}/lib)
+
+if (${PAL_PLATFORM_NAME} STREQUAL "Windows")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/vhacd.lib)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/vhacd.lib)
+elseif (${PAL_PLATFORM_NAME} STREQUAL "Mac")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/libvhacd.a)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/libvhacd.a)
+elseif (${PAL_PLATFORM_NAME} STREQUAL "Linux")
+    set(${LIB_NAME}_LIBRARY_DEBUG   ${${LIB_NAME}_LIBS_DIR}/../debug/lib/libvhacd.a)
+    set(${LIB_NAME}_LIBRARY_RELEASE ${${LIB_NAME}_LIBS_DIR}/libvhacd.a)
+endif()
+
+set(${LIB_NAME}_LIBRARY
+    "$<$<CONFIG:profile>:${${LIB_NAME}_LIBRARY_RELEASE}>"
+    "$<$<CONFIG:release>:${${LIB_NAME}_LIBRARY_RELEASE}>"
+    "$<$<CONFIG:debug>:${${LIB_NAME}_LIBRARY_DEBUG}>")
+
+add_library(${TARGET_WITH_NAMESPACE} INTERFACE IMPORTED GLOBAL)
+ly_target_include_system_directories(
+    TARGET ${TARGET_WITH_NAMESPACE} INTERFACE ${${LIB_NAME}_INCLUDE_DIR})
+target_link_libraries(
+    ${TARGET_WITH_NAMESPACE}
+    INTERFACE ${${LIB_NAME}_LIBRARY})
+
+set(${LIB_NAME}_FOUND True)

+ 79 - 0
package-system/v-hacd/build_package_image.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+# 
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import argparse
+import shutil
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent / 'Scripts'))
+from builders.vcpkgbuilder import VcpkgBuilder
+import builders.monkeypatch_tempdir_cleanup
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--platform-name',
+        dest='platformName',
+        choices=['windows', 'mac', 'linux'],
+        default=VcpkgBuilder.defaultPackagePlatformName(),
+    )
+    args = parser.parse_args()
+
+    packageSystemDir = Path(__file__).resolve().parents[1]
+    packageSourceDir = packageSystemDir / 'v-hacd'
+    outputDir = packageSystemDir / f'v-hacd-{args.platformName}'
+
+    cmakeFindFile = packageSourceDir / f'Findv-hacd_{args.platformName}.cmake'
+    if not cmakeFindFile.exists():
+        cmakeFindFile = packageSourceDir / 'Findv-hacd.cmake'
+
+    with TemporaryDirectory() as tempdir:
+        tempdir = Path(tempdir)
+        
+        builder = VcpkgBuilder(
+            packageName='v-hacd',
+            portName='v-hacd',
+            vcpkgDir=tempdir,
+            targetPlatform=args.platformName,
+            static=True
+        )
+        
+        builder.cloneVcpkg('751fc199af8d33eb300af5edbd9e3b77c48f0bca')
+        builder.bootstrap()
+        builder.build()
+        
+        builder.copyBuildOutputTo(
+            outputDir,
+            extraFiles={
+                next(builder.vcpkgDir.glob(f'buildtrees/v-hacd/src/*/LICENSE')): outputDir / builder.packageName / 'LICENSE',
+                next(builder.vcpkgDir.glob(f'buildtrees/v-hacd/src/*/README.md')): outputDir / builder.packageName / 'README.md',
+            },
+            subdir='v-hacd'
+        )
+        
+        # vcpkg's commit 751fc19 uses v-hacd version 2.3 at commit 1a49edf
+        builder.writePackageInfoFile(
+            outputDir,
+            settings={
+                'PackageName': f'v-hacd-2.3-1a49edf-rev1-{args.platformName}',
+                'URL': 'https://github.com/kmammou/v-hacd',
+                'License': 'BSD-3-Clause',
+                'LicenseFile': 'v-hacd/LICENSE'
+            },
+        )
+        
+        shutil.copy2(
+            src=cmakeFindFile,
+            dst=outputDir / 'Findv-hacd.cmake'
+        )
+
+if __name__ == '__main__':
+    main()

+ 6 - 3
package_build_list_host_darwin.json

@@ -1,5 +1,8 @@
 {
     "comment" : "This is the list that applies to darwin hosts",
+    "comment2" : "build_from_source is package name --> build script to call with params",
+    "comment3" : "build_from_folder is package name --> folder containing built image of package",
+    "comment4" : "Note:  Build from source occurs before build_from_folder",
     "build_from_source" : {
         "AWSNativeSDK-1.7.167-rev3-mac" : "Scripts/extras/pull_and_build_from_git.py ../../package-system/AWSNativeSDK --platform-name Mac --package-root ../../package-system --clean",
         "AWSNativeSDK-1.7.167-rev3-ios" : "Scripts/extras/pull_and_build_from_git.py ../../package-system/AWSNativeSDK --platform-name iOS --package-root ../../package-system --clean",
@@ -24,13 +27,13 @@
         "poly2tri-7f0487a-rev1-mac": "package-system/poly2tri/build_package_image.py --platform-name mac",
         "v-hacd-2.3-1a49edf-rev1-mac": "package-system/v-hacd/build_package_image.py --platform-name mac",
         "SPIRVCross-2021.04.29-rev1-mac": "Scripts/extras/pull_and_build_from_git.py ../../package-system/SPIRVCross --platform-name Mac --package-root ../../package-system --clean",
-        "DirectXShaderCompilerDxc-1.6.2104-o3de-rev2-mac": "Scripts/extras/pull_and_build_from_git.py ../../package-system/DirectXShaderCompiler --platform-name Mac --package-root ../../package-system  --clean",
+        "DirectXShaderCompilerDxc-1.6.2104-o3de-rev2-mac": "Scripts/extras/pull_and_build_from_git.py ../../package-system/DirectXShaderCompiler --platform-name Mac --package-root ../../package-system --clean",
         "tiff-4.2.0.10-mac" : "package-system/tiff/build_package_image.py --platform mac",
         "tiff-4.2.0.10-ios" : "package-system/tiff/build_package_image.py --platform ios",
         "python-3.7.10-rev1-darwin" : "package-system/python/build_package_image.py",
         "mcpp-2.7.2_az.1-rev1-mac": "package-system/mcpp/get_and_build_mcpp.py mcpp-2.7.2_az.1-rev1",
-        "mikkelsen-1.0.0.4-mac": "mikkelsen/build_package_image.py --platform mac",
-        "mikkelsen-1.0.0.4-ios": "mikkelsen/build_package_image.py --platform ios"  
+        "mikkelsen-1.0.0.4-mac": "package-system/mikkelsen/build_package_image.py --platform mac",
+        "mikkelsen-1.0.0.4-ios": "package-system/mikkelsen/build_package_image.py --platform ios"  
     },
     "build_from_folder" : { 
         "AWSNativeSDK-1.7.167-rev3-mac" : "package-system/AWSNativeSDK-mac",

+ 4 - 1
package_build_list_host_linux.json

@@ -1,5 +1,8 @@
 {
     "comment" : "This is the list that applies to linux hosts",
+    "comment2" : "build_from_source is package name --> build script to call with params",
+    "comment3" : "build_from_folder is package name --> folder containing built image of package",
+    "comment4" : "Note:  Build from source occurs before build_from_folder",
     "build_from_source" : {
         "AWSNativeSDK-1.7.167-rev5-linux" : "Scripts/extras/pull_and_build_from_git.py ../../package-system/AWSNativeSDK --platform-name Linux --package-root ../../package-system --clean",
         "Lua-5.3.5-rev5-linux" : "Scripts/extras/pull_and_build_from_git.py ../../package-system/Lua --platform-name Linux --package-root ../../package-system --clean",
@@ -19,7 +22,7 @@
         "DirectXShaderCompilerDxc-1.6.2104-o3de-rev2-linux": "Scripts/extras/pull_and_build_from_git.py ../../package-system/DirectXShaderCompiler --platform-name Linux --package-root ../../package-system --clean",
         "tiff-4.2.0.10-linux" : "package-system/tiff/build_package_image.py --platform linux",
         "python-3.7.10-rev2-linux" : "package-system/python/build_package_image.py",
-        "mikkelsen-1.0.0.4-linux": "mikkelsen/build_package_image.py"
+        "mikkelsen-1.0.0.4-linux": "package-system/mikkelsen/build_package_image.py"
     },
     "build_from_folder" : {
         "AWSGameLiftServerSDK-3.4.1-rev1-linux" : "package-system/AWSGameLiftServerSDK/linux",

+ 4 - 4
package_build_list_host_windows.json

@@ -1,7 +1,7 @@
 {
     "comment" : "This is the list that applies to windows hosts",
-    "comment2" : "build_from_source is package name --> folder build script lives in",
-    "comment3" : "build_from_folder is package name --> folder containing image of package",
+    "comment2" : "build_from_source is package name --> build script to call with params",
+    "comment3" : "build_from_folder is package name --> folder containing built image of package",
     "comment4" : "Note:  Build from source occurs before build_from_folder",
     "build_from_source" : {
         "AWSNativeSDK-1.7.167-rev3-windows" : "Scripts/extras/pull_and_build_from_git.py ../../package-system/AWSNativeSDK --platform-name Windows --package-root ../../package-system --clean",
@@ -34,8 +34,8 @@
         "v-hacd-2.3-1a49edf-rev1-windows": "package-system/v-hacd/build_package_image.py --platform-name windows",
         "python-3.7.10-rev1-windows" : "package-system/python/build_package_image.py",
         "amd-ags-5.4.1-rev2-windows" : "package-system/amd-ags-windows/build_package_image.py",
-        "mikkelsen-1.0.0.4-windows": "mikkelsen/build_package_image.py",
-        "mikkelsen-1.0.0.4-android": "mikkelsen/build_package_image.py --platform android"
+        "mikkelsen-1.0.0.4-windows": "package-system/mikkelsen/build_package_image.py",
+        "mikkelsen-1.0.0.4-android": "package-system/mikkelsen/build_package_image.py --platform android"
     },
   "build_from_folder": {
     "AWSGameLiftServerSDK-3.4.1-rev1-windows" : "package-system/AWSGameLiftServerSDK/windows",

この差分においてかなりの量のファイルが変更されているため、一部のファイルを表示していません